@qwen-code/qwen-code 0.19.2 → 0.19.3-nightly.20260701.a974594d7

package/chunks/{chunk-JTYRZODB.js → chunk-IBEM64M4.js}

@@ -7,28 +7,28 @@ import {
   require_jsx_runtime,
   use_stdin_default,
   use_stdout_default
-} from "./chunk-UAARJR2G.js";
+} from "./chunk-N4V4VBP6.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
 import {
   sanitizeFilenameForDisplay
-} from "./chunk-CGOMICBE.js";
+} from "./chunk-GDIG7TMG.js";
 import {
   t
-} from "./chunk-5JZLXFPD.js";
+} from "./chunk-3O2BJMFW.js";
 import {
   fetchGitDiff,
   findProviderByCredentials,
   resolveMetadataKey
-} from "./chunk-PXFFKNCO.js";
+} from "./chunk-35FH347N.js";
 import {
   KittySequenceOverflowEvent,
   logKittySequenceOverflow
-} from "./chunk-WA5OJGFL.js";
+} from "./chunk-B5MPZI4K.js";
 import {
   createDebugLogger
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-AVQDCKNF.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -759,6 +759,7 @@ var useFocus = /* @__PURE__ */ __name(() => {
 // packages/cli/src/ui/contexts/KeypressContext.tsx
 var import_jsx_runtime = __toESM(require_jsx_runtime(), 1);
 var ESC3 = "\x1B";
+var OPTION_T_COMPOSED_GLYPH = "\u2020";
 var PASTE_MODE_PREFIX = `${ESC3}[200~`;
 var PASTE_MODE_SUFFIX = `${ESC3}[201~`;
 var KITTY_SEQUENCE_TIMEOUT_MS = 200;
@@ -1529,6 +1530,10 @@ function KeypressProvider({
       if (key.name === "return" && key.sequence === `${ESC3}\r`) {
         key.meta = true;
       }
+      if (process.platform === "darwin" && !isPaste && key.sequence === OPTION_T_COMPOSED_GLYPH) {
+        key.name = "t";
+        key.meta = true;
+      }
       broadcast({ ...key, paste: isPaste });
     }, "handleKeypress");
     const clearRawFlushTimeout = /* @__PURE__ */ __name(() => {
@@ -2036,7 +2041,11 @@ function convertToHistoryItems(conversation, config) {
             });
             currentToolGroup = [];
           }
-          items.push({ type: "gemini", text });
+          items.push({
+            type: "gemini",
+            text,
+            timestamp: new Date(record.timestamp).getTime()
+          });
         }
         for (const fc of functionCalls) {
           const tool = getTool(config, fc.name);
@@ -2148,14 +2157,33 @@ function expandCollapsedHistory(items) {
   return items.filter((item) => item.display?.kind !== "collapse-summary").map(stripSuppressOnRestore);
 }
 __name(expandCollapsedHistory, "expandCollapsedHistory");
-function applyCollapsePolicyAndSummary(rawItems, collapseOnResume) {
+function applyCollapsePolicyAndSummary(rawItems, collapseOnResume, collapsePreviewCount = 0) {
   if (!collapseOnResume) return rawItems;
-  const uiHistoryItems = applyResumeDisplayPolicy(rawItems);
-  if (rawItems.length > 0) {
+  if (collapsePreviewCount === -1) return rawItems;
+  let boundary = rawItems.length;
+  if (collapsePreviewCount > 0) {
+    let userTurnCount = 0;
+    for (let i = rawItems.length - 1; i >= 0; i--) {
+      if (rawItems[i].type === "user" /* USER */) {
+        userTurnCount++;
+        if (userTurnCount === collapsePreviewCount) {
+          boundary = i;
+          break;
+        }
+      }
+    }
+    if (userTurnCount < collapsePreviewCount) {
+      boundary = 0;
+    }
+  }
+  const hiddenItems = applyResumeDisplayPolicy(rawItems.slice(0, boundary));
+  const visibleItems = rawItems.slice(boundary);
+  const uiHistoryItems = [...hiddenItems, ...visibleItems];
+  if (boundary > 0) {
     const nextId = rawItems[rawItems.length - 1].id + 1;
     return [
       ...uiHistoryItems,
-      { id: nextId, ...createHistoryCollapseSummaryItem(rawItems.length) }
+      { id: nextId, ...createHistoryCollapseSummaryItem(boundary) }
     ];
   }
   return uiHistoryItems;

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

@@ -4,36 +4,40 @@ import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-WA5OJGFL.js";
-import {
-  createChildAbortController
-} from "./chunk-64WXLC72.js";
+} from "./chunk-B5MPZI4K.js";
 import {
   RequestTokenizer
-} from "./chunk-KBXLIVWQ.js";
+} from "./chunk-DX3TKXNT.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-YPCPZSZB.js";
 import {
   GenerateContentResponse
 } from "./chunk-55ZMG67I.js";
+import {
+  createChildAbortController
+} from "./chunk-64WXLC72.js";
+import {
+  buildRuntimeFetchOptions,
+  redactProxyError
+} from "./chunk-FQDMX5IL.js";
 import {
   createDebugLogger,
   isAbortError
-} from "./chunk-C4K3FEQ2.js";
+} from "./chunk-AVQDCKNF.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 {
@@ -7229,6 +7232,12 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
   getDefaultGenerationConfig() {
     return {};
   }
+  getResponseParsingOptions(model) {
+    if (this.isGlmModel(model ?? this.contentGeneratorConfig.model)) {
+      return { taggedThinkingTags: true };
+    }
+    return {};
+  }
   /**
    * Add cache control flag to specified message(s) for DashScope providers
    */
@@ -7995,6 +8004,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 +8014,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 +8155,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 +8181,7 @@ var ContentGenerationPipeline = class {
           try {
             yield* innerStream;
           } finally {
-            ac.abort();
+            perRequestAc.abort();
           }
         }
         __name(drainThenCleanup, "drainThenCleanup");
@@ -8138,6 +8248,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);
     }
   }
@@ -8320,7 +8438,7 @@ var ContentGenerationPipeline = class {
     const effectiveModel = request.model || this.contentGeneratorConfig.model;
     const providerOverrides = this.config.provider.getRequestContextOverrides?.() ?? {};
     const toolCallParser = isStreaming ? new StreamingToolCallParser() : void 0;
-    const responseParsingOptions = this.config.provider.getResponseParsingOptions?.();
+    const responseParsingOptions = this.config.provider.getResponseParsingOptions?.(effectiveModel);
     const taggedThinkingParser = isStreaming && responseParsingOptions?.taggedThinkingTags ? new TaggedThinkingParser() : void 0;
     return {
       model: effectiveModel,
@@ -8344,7 +8462,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 +8479,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 +8519,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 +8562,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 +8609,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)}`
       );