@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260630.e00fe6a27

package/chunks/{chunk-XKBP7M7A.js → chunk-RYBSUGOR.js}

@@ -4,36 +4,40 @@ import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-WA5OJGFL.js";
-import {
-  createChildAbortController
-} from "./chunk-64WXLC72.js";
+} from "./chunk-SS6WJMQK.js";
 import {
   RequestTokenizer
-} from "./chunk-KBXLIVWQ.js";
+} from "./chunk-ZFPRYHWR.js";
 import {
-  CAPPED_DEFAULT_MAX_TOKENS,
   DASHSCOPE_PROXY_BASE_URL,
   DEFAULT_DASHSCOPE_BASE_URL,
   DEFAULT_MAX_RETRIES,
+  DEFAULT_STREAM_IDLE_TIMEOUT_MS,
   DEFAULT_TIMEOUT,
-  buildRuntimeFetchOptions,
+  MAX_STREAM_IDLE_TIMEOUT_MS,
+  QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,
   hasExplicitOutputLimit,
   parsePositiveIntegerEnvValue,
-  redactProxyError,
   tokenLimit
-} from "./chunk-F6XNTYNE.js";
+} from "./chunk-YTFBURQD.js";
 import {
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-CGEGHF2C.js";
+} from "./chunk-BKXBARJZ.js";
 import {
   GenerateContentResponse
 } from "./chunk-55ZMG67I.js";
+import {
+  createChildAbortController
+} from "./chunk-64WXLC72.js";
+import {
+  buildRuntimeFetchOptions,
+  redactProxyError
+} from "./chunk-E6XQPQXW.js";
 import {
   createDebugLogger,
   isAbortError
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -6995,16 +6999,15 @@ var DefaultOpenAICompatibleProvider = class {
    *      configured value entirely (backend may support larger limits)
    * 2. If user didn't configure max_tokens:
    *    - Check QWEN_CODE_MAX_OUTPUT_TOKENS env var first
-   *    - Otherwise use min(modelLimit, CAPPED_DEFAULT_MAX_TOKENS=8K)
-   *    - Requests hitting the 8K cap get one clean retry at 64K (geminiChat.ts)
+   *    - Otherwise use the model's output limit
    * 3. If model has no specific limit (tokenLimit returns default):
-   *    - Still apply CAPPED_DEFAULT_MAX_TOKENS as safeguard
+   *    - Use DEFAULT_OUTPUT_TOKEN_LIMIT
    *
    * Examples:
    * - User sets 4K, known model limit 64K → uses 4K (respects user preference)
    * - User sets 100K, known model limit 64K → uses 64K (capped to avoid API error)
    * - User sets 100K, unknown model → uses 100K (respects user, backend may support it)
-   * - User not set, model limit 64K → uses 8K (capped default for slot optimization)
+   * - User not set, model limit 64K → uses 64K
    * - User not set, model limit 4K → uses 4K (model limit is lower)
    * - User not set, env QWEN_CODE_MAX_OUTPUT_TOKENS=16000 -> uses 16K
    *
@@ -7032,7 +7035,7 @@ var DefaultOpenAICompatibleProvider = class {
       if (envMaxTokens !== void 0) {
         effectiveMaxTokens = isKnownModel ? Math.min(envMaxTokens, modelLimit) : envMaxTokens;
       } else {
-        effectiveMaxTokens = Math.min(modelLimit, CAPPED_DEFAULT_MAX_TOKENS);
+        effectiveMaxTokens = modelLimit;
       }
     }
     return {
@@ -7995,6 +7998,7 @@ var StreamingToolCallParser = class {
 };
 
 // packages/core/src/core/openaiContentGenerator/pipeline.ts
+var debugLogger3 = createDebugLogger("OPENAI_PIPELINE");
 var StreamContentError = class extends Error {
   static {
     __name(this, "StreamContentError");
@@ -8004,17 +8008,114 @@ var StreamContentError = class extends Error {
     this.name = "StreamContentError";
   }
 };
+var StreamInactivityTimeoutError = class extends Error {
+  constructor(idleMs, chunksReceived, streamLifetimeMs) {
+    super(
+      `No stream activity for ${idleMs}ms after ${chunksReceived} chunks (stream lifetime: ${streamLifetimeMs}ms)`
+    );
+    this.idleMs = idleMs;
+    this.chunksReceived = chunksReceived;
+    this.streamLifetimeMs = streamLifetimeMs;
+    this.name = "StreamInactivityTimeoutError";
+  }
+  static {
+    __name(this, "StreamInactivityTimeoutError");
+  }
+  code = "ETIMEDOUT";
+};
+function resolveStreamIdleTimeoutMs(config) {
+  const fromConfig = config.streamIdleTimeoutMs;
+  if (typeof fromConfig === "number") {
+    if (Number.isInteger(fromConfig) && fromConfig <= MAX_STREAM_IDLE_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.`
+    );
+  }
+  const raw = process.env[QWEN_STREAM_IDLE_TIMEOUT_MS_ENV];
+  const trimmed = raw?.trim();
+  if (trimmed) {
+    if (/^\d+$/.test(trimmed)) {
+      const parsed = Number(trimmed);
+      if (parsed <= MAX_STREAM_IDLE_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.`
+    );
+  }
+  return DEFAULT_STREAM_IDLE_TIMEOUT_MS;
+}
+__name(resolveStreamIdleTimeoutMs, "resolveStreamIdleTimeoutMs");
+async function* withStreamInactivityTimeout(source, idleMs, abortRequest, parentSignal) {
+  const it = source[Symbol.asyncIterator]();
+  const streamStartedAt = Date.now();
+  let chunksReceived = 0;
+  try {
+    while (true) {
+      const nextPromise = it.next();
+      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);
+        timer.unref?.();
+      });
+      let result;
+      try {
+        result = await Promise.race([nextPromise, timeout]);
+      } catch (err) {
+        void Promise.resolve(nextPromise).catch(() => {
+        });
+        throw err;
+      } finally {
+        if (timer !== void 0) clearTimeout(timer);
+      }
+      if (result.done) return;
+      chunksReceived += 1;
+      yield result.value;
+    }
+  } finally {
+    abortRequest();
+    try {
+      await it.return?.();
+    } catch {
+    }
+  }
+}
+__name(withStreamInactivityTimeout, "withStreamInactivityTimeout");
 var ContentGenerationPipeline = class {
   constructor(config) {
     this.config = config;
     this.contentGeneratorConfig = config.contentGeneratorConfig;
     this.client = this.config.provider.buildClient();
+    this.streamIdleTimeoutMs = resolveStreamIdleTimeoutMs(
+      this.contentGeneratorConfig
+    );
   }
   static {
     __name(this, "ContentGenerationPipeline");
   }
   client;
   contentGeneratorConfig;
+  // Resolved once (config field > env > default) so the env read + any
+  // invalid-value warning happen per pipeline, not per streaming request.
+  streamIdleTimeoutMs;
   async execute(request, userPromptId) {
     return this.executeWithErrorHandling(
       request,
@@ -8048,22 +8149,25 @@ var ContentGenerationPipeline = class {
       true,
       async (openaiRequest, context) => {
         const parentSignal = request.config?.abortSignal;
-        const perRequestAc = parentSignal ? createChildAbortController(parentSignal) : void 0;
+        const perRequestAc = createChildAbortController(parentSignal);
         let stream;
         try {
           stream = await this.client.chat.completions.create(openaiRequest, {
-            signal: perRequestAc?.signal
+            signal: perRequestAc.signal
           });
         } catch (e) {
-          perRequestAc?.abort();
+          perRequestAc.abort();
           throw e;
         }
-        if (!perRequestAc) {
-          return this.processStreamWithLogging(stream, context, request);
-        }
-        const ac = perRequestAc;
-        const innerStream = this.processStreamWithLogging(
+        const idleMs = this.streamIdleTimeoutMs;
+        const guarded = idleMs > 0 ? withStreamInactivityTimeout(
           stream,
+          idleMs,
+          () => perRequestAc.abort(),
+          parentSignal
+        ) : stream;
+        const innerStream = this.processStreamWithLogging(
+          guarded,
           context,
           request
         );
@@ -8071,7 +8175,7 @@ var ContentGenerationPipeline = class {
           try {
             yield* innerStream;
           } finally {
-            ac.abort();
+            perRequestAc.abort();
           }
         }
         __name(drainThenCleanup, "drainThenCleanup");
@@ -8138,6 +8242,14 @@ var ContentGenerationPipeline = class {
       if (error instanceof StreamContentError) {
         throw redactProxyError(error);
       }
+      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);
     }
   }
@@ -8344,7 +8456,7 @@ var ContentGenerationPipeline = class {
 
 // packages/core/src/core/openaiContentGenerator/errorHandler.ts
 init_esbuild_shims();
-var debugLogger3 = createDebugLogger("OPENAI_ERROR");
+var debugLogger4 = createDebugLogger("OPENAI_ERROR");
 var EnhancedErrorHandler = class {
   constructor(shouldSuppressLogging = () => false) {
     this.shouldSuppressLogging = shouldSuppressLogging;
@@ -8361,7 +8473,7 @@ var EnhancedErrorHandler = class {
       isTimeoutError
     );
     if (!this.shouldSuppressErrorLogging(redactedError, request)) {
-      debugLogger3.error("OpenAI API Error:", errorMessage);
+      debugLogger4.error("OpenAI API Error:", errorMessage);
     }
     if (isTimeoutError) {
       throw new Error(
@@ -8401,7 +8513,7 @@ ${tips.join("\n")}`;
 };
 
 // packages/core/src/core/openaiContentGenerator/openaiContentGenerator.ts
-var debugLogger4 = createDebugLogger("OPENAI");
+var debugLogger5 = createDebugLogger("OPENAI");
 var OpenAIContentGenerator = class {
   static {
     __name(this, "OpenAIContentGenerator");
@@ -8444,7 +8556,7 @@ var OpenAIContentGenerator = class {
         totalTokens: result.totalTokens
       };
     } catch (error) {
-      debugLogger4.warn(
+      debugLogger5.warn(
         "Failed to calculate tokens with new tokenizer, falling back to simple method:",
         error
       );
@@ -8491,7 +8603,7 @@ var OpenAIContentGenerator = class {
       };
     } catch (error) {
       const redactedError = redactProxyError(error);
-      debugLogger4.error("OpenAI API Embedding Error:", redactedError);
+      debugLogger5.error("OpenAI API Embedding Error:", redactedError);
       throw new Error(
         `OpenAI API error: ${redactedError instanceof Error ? redactedError.message : String(redactedError)}`
       );

package/chunks/{chunk-BG4BIP7F.js → chunk-SBBN4BWR.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-OFEVLU4C.js";
 import {
   SchemaValidator
-} from "./chunk-TOEGRAVX.js";
+} from "./chunk-BX5YO7UW.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -113,7 +113,9 @@ async function runSideQuery(config, options) {
     config: requestConfig,
     ...options.maxAttempts !== void 0 && {
       maxAttempts: options.maxAttempts
-    }
+    },
+    ...options.stream !== void 0 && { stream: options.stream },
+    ...options.failClosed !== void 0 && { failClosed: options.failClosed }
   });
   const customError = options.validate?.(result.text);
   if (customError) {

package/chunks/{chunk-T2VDEFUU.js → chunk-SKQZZVAV.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   atomicWriteFileSync
-} from "./chunk-3UALQ56H.js";
+} from "./chunk-3227DZO4.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-5R4SBCX6.js → chunk-SL5MOGQH.js}

@@ -6,16 +6,16 @@ import {
 import {
   JsonFormatter,
   parseAndFormatApiError
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-RIP623NO.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,
   FatalTurnLimitedError,
   createDebugLogger
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   runExitCleanup
-} from "./chunk-GYZQA2FO.js";
+} from "./chunk-YLZJCUH6.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/chunk-SMXULRAN.js

@@ -0,0 +1,37 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  themeManager
+} from "./chunk-I4H7PRWQ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+
+// packages/cli/src/ui/semantic-colors.ts
+init_esbuild_shims();
+var theme = {
+  get text() {
+    return themeManager.getSemanticColors().text;
+  },
+  get background() {
+    return themeManager.getSemanticColors().background;
+  },
+  get border() {
+    return themeManager.getSemanticColors().border;
+  },
+  get ui() {
+    return themeManager.getSemanticColors().ui;
+  },
+  get status() {
+    return themeManager.getSemanticColors().status;
+  }
+};
+
+export {
+  theme
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */