@qwen-code/qwen-code 0.21.6 → 0.21.7-nightly.20260808.4ec0371e6

package/chunks/{chunk-HY25ULVN.js → chunk-F3LPXDJP.js}

@@ -3,45 +3,57 @@
 import {
   DashScopeOpenAICompatibleProvider,
   DefaultOpenAICompatibleProvider
-} from "./chunk-HU5TUALO.js";
-import {
-  RequestTokenizer
-} from "./chunk-H36SETQS.js";
-import {
-  DEFAULT_STREAM_IDLE_TIMEOUT_MS,
-  MAX_STREAM_IDLE_TIMEOUT_MS,
-  QWEN_STREAM_IDLE_TIMEOUT_MS_ENV
-} from "./chunk-GLNBDYUX.js";
-import {
-  createChildAbortController
-} from "./chunk-DJ2GSRLV.js";
+} from "./chunk-IIJEYBNH.js";
 import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-4LKVQFHM.js";
+} from "./chunk-DREZZAZM.js";
+import {
+  applyOfficialOpenAIPromptCaching,
+  isOfficialOpenAIEndpoint
+} from "./chunk-SAH4BD2J.js";
+import {
+  getCurrentAgentId
+} from "./chunk-CPG6P4GG.js";
 import {
   InvalidStreamError
 } from "./chunk-2J3OJGTL.js";
+import {
+  isInForkExecution
+} from "./chunk-IA7TGCN2.js";
 import {
   getRateLimitErrorDetails
-} from "./chunk-6O5DVH27.js";
+} from "./chunk-M6HMMKVG.js";
+import {
+  RequestTokenizer
+} from "./chunk-B2GJNDTV.js";
 import {
   safeJsonParse
-} from "./chunk-WK4TJUEA.js";
+} from "./chunk-CKASRHZI.js";
+import {
+  DEFAULT_STREAM_IDLE_TIMEOUT_MS,
+  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 {
   getToolCallPreparations,
   runtimeDiagnostics
 } from "./chunk-GLCZKT5V.js";
+import {
+  createChildAbortController
+} from "./chunk-DJ2GSRLV.js";
 import {
   reportOpenAiChunk,
   reportOpenAiRequest,
   reportOpenAiResponse
-} from "./chunk-URN76TKR.js";
+} from "./chunk-WCG5O7IP.js";
 import {
   ProtocolTagSanitizedEvent,
   logProtocolTagSanitized
-} from "./chunk-PX5DNLSA.js";
+} from "./chunk-XCG76UE6.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
@@ -51,14 +63,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 +952,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 +1012,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 +1127,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 +1139,7 @@ async function* withStreamInactivityTimeout(source, idleMs, abortRequest, parent
     }
   }
 }
-__name(withStreamInactivityTimeout, "withStreamInactivityTimeout");
+__name(withStreamGuards, "withStreamGuards");
 var ContentGenerationPipeline = class {
   constructor(config) {
     this.config = config;
@@ -1069,6 +1148,9 @@ var ContentGenerationPipeline = class {
     this.streamIdleTimeoutMs = resolveStreamIdleTimeoutMs(
       this.contentGeneratorConfig
     );
+    this.streamMaxLifetimeMs = resolveStreamMaxLifetimeMs(
+      this.contentGeneratorConfig
+    );
   }
   static {
     __name(this, "ContentGenerationPipeline");
@@ -1079,6 +1161,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 +1239,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 +1390,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 +1414,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);
     }
   }
@@ -1396,10 +1489,18 @@ var ContentGenerationPipeline = class {
         baseRequest["tool_choice"] = "none";
       }
     }
-    const providerRequest = this.config.provider.buildRequest(
+    let providerRequest = this.config.provider.buildRequest(
       baseRequest,
       userPromptId
     );
+    if (this.contentGeneratorConfig.enableCacheControl !== false && isOfficialOpenAIEndpoint(this.contentGeneratorConfig)) {
+      providerRequest = applyOfficialOpenAIPromptCaching(
+        providerRequest,
+        this.config.cliConfig.getSessionId?.(),
+        request.promptCacheSharing === true,
+        isInForkExecution() ? void 0 : getCurrentAgentId() ?? void 0
+      );
+    }
     const model = (context.model ?? "").toLowerCase();
     const isDashScope = DashScopeOpenAICompatibleProvider.isDashScopeProvider(
       this.contentGeneratorConfig

package/chunks/{chunk-D3UEZIQH.js → chunk-FJ6YHWHZ.js}

@@ -15,7 +15,7 @@ import {
   HOME_ENV_BOOTSTRAP_KEYS,
   PROJECT_ENV_HARDCODED_EXCLUSIONS,
   publishPendingCompileCache
-} from "./chunk-6PEXNQTX.js";
+} from "./chunk-ALFTV7GA.js";
 import {
   require_strip_json_comments
 } from "./chunk-ALGGS7UH.js";
@@ -87,7 +87,7 @@ function readHomeEnvIntoFastPath(file) {
   if (!fs.existsSync(file)) return;
   try {
     const parsed = dotenv.parse(fs.readFileSync(file, "utf8"));
-    for (const key of PROJECT_ENV_HARDCODED_EXCLUSIONS) {
+    for (const key of HOME_ENV_BOOTSTRAP_KEYS) {
       if (parsed[key] && !Object.hasOwn(process.env, key)) {
         process.env[key] = parsed[key];
       }

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-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);
 }