@qwen-code/qwen-code 0.18.0-preview.2 → 0.18.1-nightly.20260616.a68b2e1e7

package/chunks/{chunk-JVQOQ3OU.js → chunk-IQHSD7K5.js}

@@ -5,7 +5,7 @@ import {
   Storage,
   resolvePath,
   sanitizeCwd
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-CNHFPN7T.js → chunk-JZFEL3RB.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   ToolNames
-} from "./chunk-2ZTWI7KH.js";
+} from "./chunk-6WPY6ES3.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-UAMOBVVW.js → chunk-LXYWINWF.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-P4J26VDS.js → chunk-LYRSMKLS.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   atomicWriteFileSync
-} from "./chunk-UAMOBVVW.js";
+} from "./chunk-LXYWINWF.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-Y7R6H6FT.js → chunk-LYSND7KR.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-JXAZUMDW.js";
+} from "./chunk-HA2UEYZP.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -467,10 +467,15 @@ var PATTERNS = [
   // -------------------
   // Zhipu GLM
   // -------------------
-  [/^glm-5/, 202752],
-  // GLM-5: exact vendor limit
+  // 1M context is the forward default for new GLM releases (GLM-5.2+, GLM-6.x,
+  // and beyond) so they need no future code change. Confirmed 200K families
+  // (GLM-5 / 5.0 / 5.1, GLM-4.x and older) are pinned explicitly first.
+  [/^glm-5(\.[01])?(-|$)/, 202752],
+  // GLM-5 / 5.0 / 5.1: 200K
+  [/^glm-(?:[5-9]|\d{2,})/, LIMITS["1m"]],
+  // GLM-5.2+, 6.x..9.x, 10.x+: 1M
   [/^glm-/, 202752],
-  // GLM fallback: 128K
+  // GLM <=4.x / non-numeric fallback: 200K
   // -------------------
   // MiniMax
   // -------------------

package/chunks/{chunk-AVW55ZCO.js → chunk-M5PJ5QAF.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   RequestTokenizer
-} from "./chunk-CWV3SJZS.js";
-import {
-  createChildAbortController
-} from "./chunk-64WXLC72.js";
+} from "./chunk-3NRO6NHX.js";
 import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-ZK4AMNIU.js";
+} from "./chunk-A3OEZT2F.js";
+import {
+  createChildAbortController
+} from "./chunk-64WXLC72.js";
 import {
   buildRuntimeFetchOptions,
   redactProxyError
-} from "./chunk-LR62TEET.js";
+} from "./chunk-NNIYWQIS.js";
 import {
   CAPPED_DEFAULT_MAX_TOKENS,
   DASHSCOPE_PROXY_BASE_URL,
@@ -25,14 +25,14 @@ import {
   runtimeDiagnostics,
   safeJsonParse,
   tokenLimit
-} from "./chunk-Y7R6H6FT.js";
+} from "./chunk-LYSND7KR.js";
 import {
   GenerateContentResponse
-} from "./chunk-BNESGOSJ.js";
+} from "./chunk-55ZMG67I.js";
 import {
   createDebugLogger,
   isAbortError
-} from "./chunk-JXAZUMDW.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);
@@ -8127,6 +8146,8 @@ var ContentGenerationPipeline = class {
     if (isStreaming) {
       baseRequest.stream = true;
       baseRequest.stream_options = { include_usage: true };
+    } else {
+      baseRequest.stream = false;
     }
     if (request.config?.tools && request.config.tools.length > 0) {
       baseRequest.tools = await OpenAIContentConverter.convertGeminiToolsToOpenAI(
@@ -8267,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;
@@ -8284,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(
@@ -8324,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");
@@ -8367,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
       );
@@ -8414,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-LR62TEET.js → chunk-NNIYWQIS.js}

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

package/chunks/chunk-OMX7CUOE.js

@@ -0,0 +1,356 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// 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
+};

package/chunks/{chunk-HV3ZZ7G4.js → chunk-OT6JA3KQ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createTask
-} from "./chunk-HGJPQK33.js";
+} from "./chunk-ZOFNJQNJ.js";
 import {
   resolveActiveTeamName
 } from "./chunk-LD2XBG6Z.js";
@@ -11,7 +11,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-2ZTWI7KH.js";
+} from "./chunk-6WPY6ES3.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-C6WMLUNB.js → chunk-QP4R5FTG.js}

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

package/chunks/chunk-QQDPRDVW.js

@@ -0,0 +1,25 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+
+// packages/core/src/plan-gate/types.ts
+init_esbuild_shims();
+var CAPPED_REVIEW_LIMIT = 5;
+var MAX_AGENT_RETRIES = 3;
+var CAP_ESCALATION_LABELS = {
+  CONTINUE: "Continue editing plan",
+  APPROVE: "Approve execution"
+};
+
+export {
+  CAPPED_REVIEW_LIMIT,
+  MAX_AGENT_RETRIES,
+  CAP_ESCALATION_LABELS
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */