@qwen-code/qwen-code 0.21.6-preview.0 → 0.21.7

package/chunks/{chunk-5CDI4UOY.js → chunk-CXE7E23H.js}

@@ -3,15 +3,17 @@
 import {
   DashScopeOpenAICompatibleProvider,
   DefaultOpenAICompatibleProvider
-} from "./chunk-HU5TUALO.js";
+} from "./chunk-IIJEYBNH.js";
 import {
   RequestTokenizer
-} from "./chunk-H36SETQS.js";
+} from "./chunk-B2GJNDTV.js";
 import {
   DEFAULT_STREAM_IDLE_TIMEOUT_MS,
-  MAX_STREAM_IDLE_TIMEOUT_MS,
-  QWEN_STREAM_IDLE_TIMEOUT_MS_ENV
-} from "./chunk-GLNBDYUX.js";
+  DEFAULT_STREAM_MAX_LIFETIME_MS,
+  MAX_STREAM_GUARD_TIMEOUT_MS,
+  QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,
+  QWEN_STREAM_MAX_LIFETIME_MS_ENV
+} from "./chunk-AXMWHKXA.js";
 import {
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
@@ -19,16 +21,16 @@ import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-4LKVQFHM.js";
+} from "./chunk-DREZZAZM.js";
 import {
   InvalidStreamError
 } from "./chunk-2J3OJGTL.js";
 import {
   getRateLimitErrorDetails
-} from "./chunk-6O5DVH27.js";
+} from "./chunk-M6HMMKVG.js";
 import {
   safeJsonParse
-} from "./chunk-WK4TJUEA.js";
+} from "./chunk-CKASRHZI.js";
 import {
   getToolCallPreparations,
   runtimeDiagnostics
@@ -37,11 +39,11 @@ import {
   reportOpenAiChunk,
   reportOpenAiRequest,
   reportOpenAiResponse
-} from "./chunk-URN76TKR.js";
+} from "./chunk-WCG5O7IP.js";
 import {
   ProtocolTagSanitizedEvent,
   logProtocolTagSanitized
-} from "./chunk-O656RSMC.js";
+} from "./chunk-2U3WZGZG.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
@@ -51,14 +53,14 @@ import {
 } from "./chunk-ZBVS26BY.js";
 import {
   redactProxyError
-} from "./chunk-BFHXDAR7.js";
+} from "./chunk-KKBPOU75.js";
 import {
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   getErrorType,
   isAbortError
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   GenerateContentResponse
 } from "./chunk-22C7BQ6D.js";
@@ -940,6 +942,21 @@ var StreamInactivityTimeoutError = class extends Error {
   }
   code = "ETIMEDOUT";
 };
+var StreamLifetimeExceededError = class extends Error {
+  constructor(maxLifetimeMs, chunksReceived, streamLifetimeMs) {
+    super(
+      `Stream exceeded its ${maxLifetimeMs}ms upstream-wait cap after ${chunksReceived} chunks without completing (wall clock: ${streamLifetimeMs}ms). Set ${QWEN_STREAM_MAX_LIFETIME_MS_ENV} to increase this cap (or 0 to disable it).`
+    );
+    this.maxLifetimeMs = maxLifetimeMs;
+    this.chunksReceived = chunksReceived;
+    this.streamLifetimeMs = streamLifetimeMs;
+    this.name = "StreamLifetimeExceededError";
+  }
+  static {
+    __name(this, "StreamLifetimeExceededError");
+  }
+  code = "ETIMEDOUT";
+};
 var NON_SSE_BODY_PREFIX_LIMIT = 512;
 function isSSECompatibleContentType(contentType) {
   if (!contentType) return true;
@@ -985,57 +1002,108 @@ function clampProviderOutputBudgetKeys(samplingParams, requestMaxTokens) {
   return samplingParams;
 }
 __name(clampProviderOutputBudgetKeys, "clampProviderOutputBudgetKeys");
-function resolveStreamIdleTimeoutMs(config) {
-  const fromConfig = config.streamIdleTimeoutMs;
+function resolveStreamGuardMs(fromConfig, configLabel, envName, defaultMs) {
   if (typeof fromConfig === "number") {
-    if (Number.isInteger(fromConfig) && fromConfig <= MAX_STREAM_IDLE_TIMEOUT_MS) {
+    if (Number.isInteger(fromConfig) && fromConfig <= MAX_STREAM_GUARD_TIMEOUT_MS) {
       return fromConfig;
     }
     console.warn(
-      `[qwen-code] Ignoring out-of-range streamIdleTimeoutMs=${fromConfig} (expected an integer in (-\u221E, ${MAX_STREAM_IDLE_TIMEOUT_MS}]); falling back to ${QWEN_STREAM_IDLE_TIMEOUT_MS_ENV}/default.`
+      `[qwen-code] Ignoring out-of-range ${configLabel}=${fromConfig} (expected an integer in (-\u221E, ${MAX_STREAM_GUARD_TIMEOUT_MS}]); falling back to ${envName}/default.`
     );
   }
-  const raw = process.env[QWEN_STREAM_IDLE_TIMEOUT_MS_ENV];
+  const raw = process.env[envName];
   const trimmed = raw?.trim();
   if (trimmed) {
     if (/^\d+$/.test(trimmed)) {
       const parsed = Number(trimmed);
-      if (parsed <= MAX_STREAM_IDLE_TIMEOUT_MS) {
+      if (parsed <= MAX_STREAM_GUARD_TIMEOUT_MS) {
         return parsed;
       }
     }
     console.warn(
-      `[qwen-code] Ignoring invalid ${QWEN_STREAM_IDLE_TIMEOUT_MS_ENV}="${raw}" (expected an integer of milliseconds in [0, ${MAX_STREAM_IDLE_TIMEOUT_MS}]); using default ${DEFAULT_STREAM_IDLE_TIMEOUT_MS}ms.`
+      `[qwen-code] Ignoring invalid ${envName}="${raw}" (expected an integer of milliseconds in [0, ${MAX_STREAM_GUARD_TIMEOUT_MS}]); using default ${defaultMs}ms.`
     );
   }
-  return DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+  return defaultMs;
+}
+__name(resolveStreamGuardMs, "resolveStreamGuardMs");
+function resolveStreamIdleTimeoutMs(config) {
+  return resolveStreamGuardMs(
+    config.streamIdleTimeoutMs,
+    "streamIdleTimeoutMs",
+    QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,
+    DEFAULT_STREAM_IDLE_TIMEOUT_MS
+  );
 }
 __name(resolveStreamIdleTimeoutMs, "resolveStreamIdleTimeoutMs");
-async function* withStreamInactivityTimeout(source, idleMs, abortRequest, parentSignal) {
+function resolveStreamMaxLifetimeMs(config) {
+  return resolveStreamGuardMs(
+    config.streamMaxLifetimeMs,
+    "streamMaxLifetimeMs",
+    QWEN_STREAM_MAX_LIFETIME_MS_ENV,
+    DEFAULT_STREAM_MAX_LIFETIME_MS
+  );
+}
+__name(resolveStreamMaxLifetimeMs, "resolveStreamMaxLifetimeMs");
+async function* withStreamGuards(source, idleMs, maxLifetimeMs, abortRequest, parentSignal) {
+  if (idleMs <= 0 && maxLifetimeMs <= 0) {
+    yield* source;
+    return;
+  }
   const it = source[Symbol.asyncIterator]();
-  const streamStartedAt = Date.now();
+  const streamStartedAt = performance.now();
+  let upstreamMs = 0;
   let chunksReceived = 0;
   try {
     while (true) {
+      const remainingMs = maxLifetimeMs > 0 ? maxLifetimeMs - upstreamMs : Number.POSITIVE_INFINITY;
+      if (remainingMs <= 0) {
+        if (parentSignal?.aborted) {
+          const abortErr = new Error("Aborted");
+          abortErr.name = "AbortError";
+          throw abortErr;
+        }
+        abortRequest();
+        throw new StreamLifetimeExceededError(
+          maxLifetimeMs,
+          chunksReceived,
+          performance.now() - streamStartedAt
+        );
+      }
       const nextPromise = it.next();
+      const awaitedAt = performance.now();
       let timer;
       const timeout = new Promise((_resolve, reject) => {
-        timer = setTimeout(() => {
-          if (parentSignal?.aborted) {
-            const abortErr = new Error("Aborted");
-            abortErr.name = "AbortError";
-            reject(abortErr);
-          } else {
-            abortRequest();
-            reject(
-              new StreamInactivityTimeoutError(
-                idleMs,
-                chunksReceived,
-                Date.now() - streamStartedAt
-              )
-            );
-          }
-        }, idleMs);
+        const idleIn = idleMs > 0 ? idleMs : Number.POSITIVE_INFINITY;
+        const wait = Math.min(idleIn, remainingMs);
+        timer = setTimeout(
+          () => {
+            if (parentSignal?.aborted) {
+              const abortErr = new Error("Aborted");
+              abortErr.name = "AbortError";
+              reject(abortErr);
+            } else if (remainingMs <= idleIn) {
+              abortRequest();
+              reject(
+                new StreamLifetimeExceededError(
+                  maxLifetimeMs,
+                  chunksReceived,
+                  performance.now() - streamStartedAt
+                )
+              );
+            } else {
+              abortRequest();
+              reject(
+                new StreamInactivityTimeoutError(
+                  idleMs,
+                  chunksReceived,
+                  performance.now() - streamStartedAt
+                )
+              );
+            }
+          },
+          Math.max(wait, 0)
+        );
         timer.unref?.();
       });
       let result;
@@ -1049,6 +1117,7 @@ async function* withStreamInactivityTimeout(source, idleMs, abortRequest, parent
         if (timer !== void 0) clearTimeout(timer);
       }
       if (result.done) return;
+      upstreamMs += performance.now() - awaitedAt;
       chunksReceived += 1;
       yield result.value;
     }
@@ -1060,7 +1129,7 @@ async function* withStreamInactivityTimeout(source, idleMs, abortRequest, parent
     }
   }
 }
-__name(withStreamInactivityTimeout, "withStreamInactivityTimeout");
+__name(withStreamGuards, "withStreamGuards");
 var ContentGenerationPipeline = class {
   constructor(config) {
     this.config = config;
@@ -1069,6 +1138,9 @@ var ContentGenerationPipeline = class {
     this.streamIdleTimeoutMs = resolveStreamIdleTimeoutMs(
       this.contentGeneratorConfig
     );
+    this.streamMaxLifetimeMs = resolveStreamMaxLifetimeMs(
+      this.contentGeneratorConfig
+    );
   }
   static {
     __name(this, "ContentGenerationPipeline");
@@ -1079,6 +1151,7 @@ var ContentGenerationPipeline = class {
   // Resolved once (config field > env > default) so the env read + any
   // invalid-value warning happen per pipeline, not per streaming request.
   streamIdleTimeoutMs;
+  streamMaxLifetimeMs;
   async execute(request, userPromptId) {
     return this.executeWithErrorHandling(
       request,
@@ -1156,9 +1229,11 @@ var ContentGenerationPipeline = class {
           throw e;
         }
         const idleMs = this.streamIdleTimeoutMs;
-        const guarded = idleMs > 0 ? withStreamInactivityTimeout(
+        const maxLifetimeMs = this.streamMaxLifetimeMs;
+        const guarded = idleMs > 0 || maxLifetimeMs > 0 ? withStreamGuards(
           stream,
           idleMs,
+          maxLifetimeMs,
           () => perRequestAc.abort(),
           parentSignal
         ) : stream;
@@ -1305,6 +1380,22 @@ var ContentGenerationPipeline = class {
       if (error instanceof StreamContentError) {
         throw redactProxyError(error);
       }
+      if (error instanceof StreamInactivityTimeoutError || error instanceof StreamLifetimeExceededError) {
+        const isLifetime = error instanceof StreamLifetimeExceededError;
+        debugLogger3.warn(
+          isLifetime ? "OpenAI stream lifetime cap exceeded" : "OpenAI stream inactivity timeout",
+          {
+            chunksReceived: error.chunksReceived,
+            // Wall clock, labelled apart from the cap so the two numbers in
+            // the log reconcile the same way the error message does.
+            wallClockMs: error.streamLifetimeMs,
+            ...isLifetime ? {
+              maxLifetimeMs: error.maxLifetimeMs
+            } : { idleMs: error.idleMs }
+          }
+        );
+        throw redactProxyError(error);
+      }
       if (context.pendingThinkingTagCandidate?.closingTagName && request.config?.abortSignal?.aborted !== true) {
         context.pendingThinkingTagCandidate = void 0;
         context.pendingUntrustedResponseParts = void 0;
@@ -1313,14 +1404,6 @@ var ContentGenerationPipeline = class {
           "PROTOCOL_TAG_LEAK"
         );
       }
-      if (error instanceof StreamInactivityTimeoutError) {
-        debugLogger3.warn("OpenAI stream inactivity timeout", {
-          idleMs: error.idleMs,
-          chunksReceived: error.chunksReceived,
-          streamLifetimeMs: error.streamLifetimeMs
-        });
-        throw redactProxyError(error);
-      }
       await this.handleError(error, context, request);
     }
   }

package/chunks/{chunk-URJHXOSO.js → chunk-CYR3HI5X.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   createTask
-} from "./chunk-A6SX5TAH.js";
+} from "./chunk-XCWO3SMQ.js";
 import {
   getPlanRequiredTeammatePreApprovalMessage,
   isPlanRequiredTeammateAwaitingApproval
-} from "./chunk-6WBWIPBF.js";
+} from "./chunk-BVWVWGLE.js";
 import {
   resolveActiveTeamName
 } from "./chunk-S6LOFUVP.js";
@@ -15,7 +15,7 @@ import {
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-D7D7RXIJ.js";
+} from "./chunk-IC4Z6LX6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-546CDN6D.js → chunk-DBOFL3LQ.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   resolveBundleDir
-} from "./chunk-DOA7MCDY.js";
+} from "./chunk-Y7E5LNLO.js";
 import {
   Storage
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   writeStderrLine
-} from "./chunk-OWAK7LMW.js";
+} from "./chunk-KGJGEEVR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-4LKVQFHM.js → chunk-DREZZAZM.js}

@@ -9,7 +9,7 @@ import {
   relaxSchemaForFunctionCalling,
   safeJsonParse,
   setGenAiUsageProvenance
-} from "./chunk-WK4TJUEA.js";
+} from "./chunk-CKASRHZI.js";
 import {
   setToolCallPreparations
 } from "./chunk-GLCZKT5V.js";
@@ -21,7 +21,7 @@ import {
 } from "./chunk-46UV252V.js";
 import {
   createDebugLogger
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   FinishReason,
   GenerateContentResponse

package/chunks/{chunk-2U7GPHA6.js → chunk-E33LOKRA.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   MissingCliEntryError
-} from "./chunk-WIRAPZ62.js";
+} from "./chunk-NLREQJFK.js";
 import {
   EXTERNAL_TOOL_GUARD_TOKEN_ENV
 } from "./chunk-BKHCW2BI.js";

package/chunks/{chunk-2DNKEBXY.js → chunk-EI3HZX6C.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-U25CMJYY.js → chunk-EKPKKXY2.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   themeManager
-} from "./chunk-KKN2IE7Q.js";
+} from "./chunk-CTJLZLB5.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QG2ACINA.js → chunk-EORNAQDT.js}

@@ -64,7 +64,7 @@ async function runExitCleanup(options = {}) {
 }
 __name(runExitCleanup, "runExitCleanup");
 async function cleanupCheckpoints() {
-  const { Storage } = await import("./deferred-core-runtime-KXN7HLN7.js");
+  const { Storage } = await import("./deferred-core-runtime-BWRCCFTE.js");
   const storage = new Storage(process.cwd());
   const tempDir = storage.getProjectTempDir();
   const checkpointsDir = join(tempDir, "checkpoints");

package/chunks/{chunk-432XCUHF.js → chunk-EQL65XGA.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-TYERNYH4.js → chunk-EUNWC2VS.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   atomicWriteFileSync
-} from "./chunk-UH7Z7Y45.js";
+} from "./chunk-FOGU3LJX.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-CDHNGCJI.js → chunk-EUQTXRKZ.js}

@@ -2,30 +2,30 @@
 "use strict";
 import {
   getExtensionManager
-} from "./chunk-C4GRKMUL.js";
+} from "./chunk-OHJLEW5J.js";
 import {
   parseChannelConfig
-} from "./chunk-7GYP5COR.js";
+} from "./chunk-ZXU5UHMI.js";
 import {
   getPlugin,
   registerPlugin
-} from "./chunk-DTAPI453.js";
+} from "./chunk-IUFV6FYU.js";
 import {
   sanitizeLogText
 } from "./chunk-DIEFUBV6.js";
 import {
   loadSettings
-} from "./chunk-YUVTZ4UH.js";
+} from "./chunk-PQBHU2IA.js";
 import {
   hashDaemonWorkspace
-} from "./chunk-MGSSJT27.js";
+} from "./chunk-L4N6TIP7.js";
 import {
   Storage
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   writeStderrLine,
   writeStdoutLine
-} from "./chunk-OWAK7LMW.js";
+} from "./chunk-KGJGEEVR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-UH7Z7Y45.js → chunk-FOGU3LJX.js}

@@ -3,7 +3,7 @@
 import {
   createDebugLogger,
   isNodeError
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-BU4BRCPX.js → chunk-FPM27XN4.js}

@@ -2,23 +2,23 @@
 "use strict";
 import {
   getErrorMessage
-} from "./chunk-EHMN6SEG.js";
+} from "./chunk-TDXGKHDN.js";
 import {
   extensionToOutputString,
   getExtensionManager
-} from "./chunk-C4GRKMUL.js";
+} from "./chunk-OHJLEW5J.js";
 import {
   loadSettings
-} from "./chunk-YUVTZ4UH.js";
+} from "./chunk-PQBHU2IA.js";
 import {
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-546CDN6D.js";
+} from "./chunk-DBOFL3LQ.js";
 import {
   writeStderrLine,
   writeStdoutLine
-} from "./chunk-OWAK7LMW.js";
+} from "./chunk-KGJGEEVR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-E4WHKETF.js → chunk-FVKHVJZQ.js}

@@ -3,9 +3,10 @@
 import {
   QWEN_DIR,
   Storage,
+  realpathNearestExisting,
   resolvePath,
   sanitizeCwd
-} from "./chunk-3RXUYQJI.js";
+} from "./chunk-OIVKILPI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -186,54 +187,6 @@ function isManagedMemoryPath(filePath, projectRoot, baseDir = projectRoot) {
   });
 }
 __name(isManagedMemoryPath, "isManagedMemoryPath");
-function resolveLeafSymlink(inputPath) {
-  const maxHops = 40;
-  let current = path.resolve(inputPath);
-  for (let i = 0; i < maxHops; i++) {
-    let stat;
-    try {
-      stat = fs.lstatSync(current);
-    } catch {
-      return current;
-    }
-    if (!stat.isSymbolicLink()) {
-      return current;
-    }
-    const target = fs.readlinkSync(current);
-    if (path.isAbsolute(target)) {
-      current = target;
-    } else {
-      let parent;
-      try {
-        parent = fs.realpathSync(path.dirname(current));
-      } catch {
-        parent = path.dirname(current);
-      }
-      current = path.resolve(parent, target);
-    }
-  }
-  return current;
-}
-__name(resolveLeafSymlink, "resolveLeafSymlink");
-function realpathNearestExisting(inputPath) {
-  const resolved = resolveLeafSymlink(inputPath);
-  const missingSegments = [];
-  let current = resolved;
-  while (!fs.existsSync(current)) {
-    const parent = path.dirname(current);
-    if (parent === current) {
-      return resolved;
-    }
-    missingSegments.unshift(path.basename(current));
-    current = parent;
-  }
-  try {
-    return path.join(fs.realpathSync(current), ...missingSegments);
-  } catch {
-    return resolved;
-  }
-}
-__name(realpathNearestExisting, "realpathNearestExisting");
 function isAnyAutoMemPath(absolutePath, projectRoot) {
   return isAutoMemPath(absolutePath, projectRoot) || isUserAutoMemPath(absolutePath);
 }

package/chunks/{chunk-NKST54XA.js → chunk-FZBZSYKU.js}

@@ -14,7 +14,7 @@ import {
 init_esbuild_shims();
 async function getCliVersion() {
   const pkgJson = await getPackageJson();
-  return "0.21.6-preview.0";
+  return "0.21.7";
 }
 __name(getCliVersion, "getCliVersion");