@qwen-code/qwen-code 0.19.2 → 0.19.3

package/chunks/{chunk-R36VMVEP.js → chunk-6V4NZFUS.js}

@@ -3,24 +3,24 @@
 import {
   AUTO_THEME_NAME,
   themeManager
-} from "./chunk-TMBPDHXD.js";
+} from "./chunk-I4H7PRWQ.js";
 import {
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-5JZLXFPD.js";
+} from "./chunk-R5OP2ATH.js";
 import {
   IdeClient
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-YAINVQ3Q.js";
 import {
   AuthEvent,
   IdeConnectionEvent,
   logAuth,
   logIdeConnection
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-QNKBEJO2.js";
 import {
   getErrorMessage
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

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

@@ -4,36 +4,38 @@ import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-WA5OJGFL.js";
-import {
-  createChildAbortController
-} from "./chunk-64WXLC72.js";
+} from "./chunk-QNKBEJO2.js";
 import {
   RequestTokenizer
-} from "./chunk-KBXLIVWQ.js";
+} from "./chunk-VVLOGDB6.js";
 import {
-  CAPPED_DEFAULT_MAX_TOKENS,
   DASHSCOPE_PROXY_BASE_URL,
   DEFAULT_DASHSCOPE_BASE_URL,
   DEFAULT_MAX_RETRIES,
+  DEFAULT_STREAM_IDLE_TIMEOUT_MS,
   DEFAULT_TIMEOUT,
+  MAX_STREAM_IDLE_TIMEOUT_MS,
+  QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,
   buildRuntimeFetchOptions,
   hasExplicitOutputLimit,
   parsePositiveIntegerEnvValue,
   redactProxyError,
   tokenLimit
-} from "./chunk-F6XNTYNE.js";
+} from "./chunk-U3KSMM7G.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 {
   createDebugLogger,
   isAbortError
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-UX4SGCGN.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -6995,16 +6997,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 +7033,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 +7996,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 +8006,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 +8147,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 +8173,7 @@ var ContentGenerationPipeline = class {
           try {
             yield* innerStream;
           } finally {
-            ac.abort();
+            perRequestAc.abort();
           }
         }
         __name(drainThenCleanup, "drainThenCleanup");
@@ -8138,6 +8240,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 +8454,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 +8471,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 +8511,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 +8554,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 +8601,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-BC3C4F3Q.js

@@ -0,0 +1,40 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/resolvePath.ts
+init_esbuild_shims();
+import * as os from "node:os";
+import * as path from "node:path";
+function resolvePath(p) {
+  if (!p) {
+    return "";
+  }
+  let expandedPath = p;
+  if (p.toLowerCase().startsWith("%userprofile%")) {
+    expandedPath = os.homedir() + p.substring("%userprofile%".length);
+  } else if (p === "~" || p.startsWith("~/")) {
+    expandedPath = os.homedir() + p.substring(1);
+  } else if (p.startsWith("~\\")) {
+    expandedPath = path.join(
+      os.homedir(),
+      ...p.substring(2).split(/[/\\]+/).filter(Boolean)
+    );
+  }
+  return path.normalize(expandedPath);
+}
+__name(resolvePath, "resolvePath");
+
+export {
+  resolvePath
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-CGEGHF2C.js → chunk-BKXBARJZ.js}

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

package/chunks/chunk-BMFMJINR.js

@@ -0,0 +1,45 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/workspace-service/types.ts
+init_esbuild_shims();
+var WorkspaceSettingsPartialPersistError = class extends Error {
+  static {
+    __name(this, "WorkspaceSettingsPartialPersistError");
+  }
+  committedWrites;
+  cause;
+  constructor(message, committedWrites, cause) {
+    super(message);
+    this.name = "WorkspaceSettingsPartialPersistError";
+    this.committedWrites = committedWrites;
+    this.cause = cause;
+  }
+};
+var WorkspacePermissionRulesSessionRequiredError = class extends Error {
+  static {
+    __name(this, "WorkspacePermissionRulesSessionRequiredError");
+  }
+  constructor() {
+    super(
+      "setWorkspacePermissionRules requires a live ACP session to update active permission rules"
+    );
+    this.name = "WorkspacePermissionRulesSessionRequiredError";
+  }
+};
+
+export {
+  WorkspaceSettingsPartialPersistError,
+  WorkspacePermissionRulesSessionRequiredError
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */