@qwen-code/qwen-code 0.19.6 → 0.19.7-nightly.20260708.394c1a289

package/chunks/{chunk-DMSNJDWG.js → chunk-FV7425LN.js}

@@ -5,11 +5,11 @@ import {
 } from "./chunk-OMX7CUOE.js";
 import {
   atomicWriteJSON
-} from "./chunk-T42ACHFI.js";
+} from "./chunk-7LTB54MK.js";
 import {
   Storage,
   getProjectHash
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";
@@ -21,6 +21,22 @@ import {
 init_esbuild_shims();
 import * as fs from "node:fs/promises";
 import * as path from "node:path";
+var MAX_TASK_RUNS = 20;
+function appendCronRun(runs, entry) {
+  const base = Array.isArray(runs) ? runs : [];
+  const next = [...base, entry];
+  return next.length > MAX_TASK_RUNS ? next.slice(next.length - MAX_TASK_RUNS) : next;
+}
+__name(appendCronRun, "appendCronRun");
+function generateCronTaskId() {
+  const chars = "abcdefghijklmnopqrstuvwxyz0123456789";
+  let id = "";
+  for (let i = 0; i < 8; i++) {
+    id += chars[Math.floor(Math.random() * chars.length)];
+  }
+  return id;
+}
+__name(generateCronTaskId, "generateCronTaskId");
 var TASKS_FILENAME = "scheduled_tasks.json";
 var CRON_TASKS_DISPLAY_PATH = `~/.qwen/tmp/<project-hash>/${TASKS_FILENAME}`;
 var UPDATE_LOCK_RETRY_MS = 15;
@@ -164,14 +180,33 @@ function isFiniteTimestamp(value) {
   return typeof value === "number" && Number.isFinite(value);
 }
 __name(isFiniteTimestamp, "isFiniteTimestamp");
+function isValidRuns(value) {
+  if (!Array.isArray(value)) return false;
+  return value.every((entry) => {
+    if (typeof entry !== "object" || entry === null) return false;
+    const run = entry;
+    return isFiniteTimestamp(run["at"]) && (run["kind"] === void 0 || typeof run["kind"] === "string") && (run["sessionId"] === void 0 || typeof run["sessionId"] === "string");
+  });
+}
+__name(isValidRuns, "isValidRuns");
 function isValidTask(value) {
   if (typeof value !== "object" || value === null) return false;
   const obj = value;
-  return typeof obj["id"] === "string" && typeof obj["cron"] === "string" && typeof obj["prompt"] === "string" && typeof obj["recurring"] === "boolean" && isFiniteTimestamp(obj["createdAt"]) && (obj["lastFiredAt"] === null || isFiniteTimestamp(obj["lastFiredAt"]));
+  return typeof obj["id"] === "string" && typeof obj["cron"] === "string" && typeof obj["prompt"] === "string" && typeof obj["recurring"] === "boolean" && isFiniteTimestamp(obj["createdAt"]) && (obj["lastFiredAt"] === null || isFiniteTimestamp(obj["lastFiredAt"])) && // Optional fields (added for the management UI): absent is valid and
+  // means "unnamed" / "enabled". Present-but-wrong-type routes through
+  // the same fix-or-delete contract as any other corrupt field rather
+  // than being silently coerced or dropped.
+  (obj["name"] === void 0 || typeof obj["name"] === "string") && (obj["enabled"] === void 0 || typeof obj["enabled"] === "boolean") && (obj["disabledByArchive"] === void 0 || typeof obj["disabledByArchive"] === "boolean") && // A bound sessionId must be a NON-EMPTY string: an empty string would pass
+  // a bare `typeof` check but the scheduler's truthy `task.sessionId` guard
+  // would treat it as unbound, so a "bound" task would silently run unbound.
+  (obj["sessionId"] === void 0 || typeof obj["sessionId"] === "string" && obj["sessionId"].length > 0) && (obj["runs"] === void 0 || isValidRuns(obj["runs"]));
 }
 __name(isValidTask, "isValidTask");
 
 export {
+  MAX_TASK_RUNS,
+  appendCronRun,
+  generateCronTaskId,
   CRON_TASKS_DISPLAY_PATH,
   getCronFilePath,
   readCronTasks,

package/chunks/{chunk-ALX6BUYW.js → chunk-G7ZG7CA6.js}

@@ -11,6 +11,7 @@ import {
 init_esbuild_shims();
 var EVENT_SCHEMA_VERSION = 1;
 var DEFAULT_MAX_QUEUED = 256;
+var DEFAULT_MAX_QUEUED_BYTES = 2 * 1024 * 1024;
 var DEFAULT_RING_SIZE = 8e3;
 var WARN_THRESHOLD_RATIO = 0.75;
 var WARN_RESET_RATIO = 0.375;
@@ -20,6 +21,55 @@ function getServerTimestamp(meta) {
   return typeof existing === "number" && Number.isFinite(existing) ? existing : Date.now();
 }
 __name(getServerTimestamp, "getServerTimestamp");
+function normalizeMaxQueuedBytes(value) {
+  if (value === void 0) return DEFAULT_MAX_QUEUED_BYTES;
+  if (!Number.isSafeInteger(value) || value < 1) {
+    throw new TypeError("maxQueuedBytes must be a positive safe integer");
+  }
+  return value;
+}
+__name(normalizeMaxQueuedBytes, "normalizeMaxQueuedBytes");
+function serializedByteLength(event) {
+  try {
+    const serialized = JSON.stringify(event);
+    if (serialized === void 0) return 0;
+    return Buffer.byteLength(serialized, "utf8");
+  } catch {
+    logEventSizingFailed(event.type);
+    return 0;
+  }
+}
+__name(serializedByteLength, "serializedByteLength");
+function logEventSizingFailed(type) {
+  try {
+    process.stderr.write(
+      `qwen serve: EventBus event sizing failed ${JSON.stringify({ type })}
+`
+    );
+  } catch {
+  }
+}
+__name(logEventSizingFailed, "logEventSizingFailed");
+function logSubscriberEvicted(data) {
+  try {
+    process.stderr.write(
+      `qwen serve: EventBus subscriber evicted ${JSON.stringify(data)}
+`
+    );
+  } catch {
+  }
+}
+__name(logSubscriberEvicted, "logSubscriberEvicted");
+function logSlowClientWarning(data) {
+  try {
+    process.stderr.write(
+      `qwen serve: EventBus slow_client_warning ${JSON.stringify(data)}
+`
+    );
+  } catch {
+  }
+}
+__name(logSlowClientWarning, "logSlowClientWarning");
 var SubscriberLimitExceededError = class extends Error {
   static {
     __name(this, "SubscriberLimitExceededError");
@@ -32,10 +82,11 @@ var SubscriberLimitExceededError = class extends Error {
   }
 };
 var EventBus = class {
-  constructor(ringSize = DEFAULT_RING_SIZE, maxSubscribers = DEFAULT_MAX_SUBSCRIBERS, compactionEngine) {
+  constructor(ringSize = DEFAULT_RING_SIZE, maxSubscribers = DEFAULT_MAX_SUBSCRIBERS, compactionEngine, opts = {}) {
     this.ringSize = ringSize;
     this.maxSubscribers = maxSubscribers;
     this.compactionEngine = compactionEngine;
+    this.maxQueuedBytes = normalizeMaxQueuedBytes(opts.maxQueuedBytes);
   }
   static {
     __name(this, "EventBus");
@@ -43,6 +94,7 @@ var EventBus = class {
   nextId = 1;
   ring = [];
   subs = /* @__PURE__ */ new Set();
+  maxQueuedBytes;
   closed = false;
   snapshotReplay() {
     return this.compactionEngine?.snapshot();
@@ -55,6 +107,30 @@ var EventBus = class {
   get subscriberCount() {
     return this.subs.size;
   }
+  seedReplayEvents(inputs) {
+    if (this.closed) return [];
+    if (inputs.length === 0) return [];
+    const events = [];
+    for (const input of inputs) {
+      const existingMeta = input._meta;
+      const event = {
+        id: this.nextId++,
+        v: EVENT_SCHEMA_VERSION,
+        ...input,
+        _meta: {
+          ...existingMeta ?? {},
+          serverTimestamp: getServerTimestamp(existingMeta)
+        }
+      };
+      events.push(event);
+      try {
+        this.compactionEngine?.ingest(event);
+      } catch {
+      }
+    }
+    this.ring.length = 0;
+    return events;
+  }
   /**
    * Publish an event to the bus. Returns the constructed `BridgeEvent`
    * (with `id` + `v` assigned) on success, or `undefined` when the
@@ -87,38 +163,64 @@ var EventBus = class {
     } catch {
     }
     if (this.ring.length > this.ringSize) this.ring.shift();
+    let eventBytes;
+    const getEventBytes = /* @__PURE__ */ __name(() => {
+      eventBytes ??= serializedByteLength(event);
+      return eventBytes;
+    }, "getEventBytes");
     for (const sub of Array.from(this.subs)) {
       if (sub.evicted) continue;
-      if (!sub.queue.push(event)) {
+      const pushResult = sub.queue.push(event, getEventBytes);
+      if (!pushResult.ok) {
         sub.evicted = true;
+        const evictionData = {
+          reason: pushResult.reason,
+          droppedAfter: event.id,
+          queueSize: pushResult.liveSize,
+          maxQueued: sub.maxQueued,
+          queuedBytes: pushResult.liveBytes,
+          maxQueuedBytes: sub.maxQueuedBytes,
+          ...pushResult.reason === "queue_bytes_overflow" ? { eventBytes: pushResult.eventBytes } : {}
+        };
+        logSubscriberEvicted(evictionData);
         const evictionFrame = {
           v: EVENT_SCHEMA_VERSION,
           type: "client_evicted",
-          data: { reason: "queue_overflow", droppedAfter: event.id }
+          data: evictionData
         };
         sub.queue.forcePush(evictionFrame);
         sub.queue.close();
         sub.dispose();
         continue;
       }
-      const liveSize = sub.queue.size;
-      if (!sub.warned && liveSize >= sub.warnThreshold) {
+      const liveSize = pushResult.liveSize;
+      const liveBytes = pushResult.liveBytes;
+      if (sub.warned && liveSize <= sub.warnResetThreshold && liveBytes <= sub.warnBytesResetThreshold) {
+        sub.warned = false;
+      }
+      const frameThresholdReached = liveSize >= sub.warnThreshold;
+      const byteThresholdReached = liveBytes >= sub.warnBytesThreshold;
+      if (!sub.warned && (frameThresholdReached || byteThresholdReached)) {
         sub.warned = true;
+        const threshold = frameThresholdReached && byteThresholdReached ? "frames_and_bytes" : byteThresholdReached ? "bytes" : "frames";
+        const warningData = {
+          queueSize: liveSize,
+          maxQueued: sub.maxQueued,
+          // `event.id` is always defined here — the just-published
+          // `event` is constructed at the top of `publish()` with
+          // `id: this.nextId++`. No `??` fallback needed.
+          lastEventId: event.id,
+          queuedBytes: liveBytes,
+          maxQueuedBytes: sub.maxQueuedBytes,
+          threshold
+        };
+        logSlowClientWarning(warningData);
         const warningFrame = {
           v: EVENT_SCHEMA_VERSION,
           type: "slow_client_warning",
-          data: {
-            queueSize: liveSize,
-            maxQueued: sub.maxQueued,
-            // `event.id` is always defined here — the just-published
-            // `event` is constructed at the top of `publish()` with
-            // `id: this.nextId++`. No `??` fallback needed.
-            lastEventId: event.id
-          }
+          data: warningData
         };
         sub.queue.forcePush(warningFrame);
-      } else if (sub.warned && liveSize <= sub.warnResetThreshold) {
-        sub.warned = false;
       }
     }
     return event;
@@ -145,13 +247,19 @@ var EventBus = class {
       throw new SubscriberLimitExceededError(this.maxSubscribers);
     }
     const maxQueued = opts.maxQueued ?? DEFAULT_MAX_QUEUED;
-    const queue = new BoundedAsyncQueue(maxQueued);
+    const queue = new BoundedAsyncQueue(
+      maxQueued,
+      this.maxQueuedBytes
+    );
     const sub = {
       queue,
       evicted: false,
       maxQueued,
       warnThreshold: WARN_THRESHOLD_RATIO * maxQueued,
       warnResetThreshold: WARN_RESET_RATIO * maxQueued,
+      maxQueuedBytes: this.maxQueuedBytes,
+      warnBytesThreshold: WARN_THRESHOLD_RATIO * this.maxQueuedBytes,
+      warnBytesResetThreshold: WARN_RESET_RATIO * this.maxQueuedBytes,
       warned: false,
       dispose: /* @__PURE__ */ __name(() => {
       }, "dispose")
@@ -174,7 +282,17 @@ var EventBus = class {
         });
       } else {
         const earliestInRing = this.ring[0]?.id;
-        if (earliestInRing !== void 0 && earliestInRing > opts.lastEventId + 1) {
+        if (earliestInRing === void 0 && opts.lastEventId < this.nextId - 1) {
+          queue.forcePush({
+            v: EVENT_SCHEMA_VERSION,
+            type: "state_resync_required",
+            data: {
+              reason: "seeded_replay_not_in_ring",
+              lastDeliveredId: opts.lastEventId,
+              earliestAvailableId: this.nextId
+            }
+          });
+        } else if (earliestInRing !== void 0 && earliestInRing > opts.lastEventId + 1) {
           queue.forcePush({
             v: EVENT_SCHEMA_VERSION,
             type: "state_resync_required",
@@ -268,8 +386,9 @@ function emptyAsyncIterable() {
 }
 __name(emptyAsyncIterable, "emptyAsyncIterable");
 var BoundedAsyncQueue = class {
-  constructor(maxSize) {
+  constructor(maxSize, maxBytes) {
     this.maxSize = maxSize;
+    this.maxBytes = maxBytes;
   }
   static {
     __name(this, "BoundedAsyncQueue");
@@ -286,6 +405,7 @@ var BoundedAsyncQueue = class {
    * no matter where in the queue the forced entries are.
    */
   liveCount = 0;
+  liveBytes = 0;
   /**
    * Number of LIVE (non-force-pushed) items currently waiting in the
    * buffer. Backpressure decisions in `EventBus.publish()` (the
@@ -294,18 +414,53 @@ var BoundedAsyncQueue = class {
   get size() {
     return this.liveCount;
   }
-  /** Returns true if accepted, false if dropped due to overflow. */
-  push(value) {
-    if (this.closed) return false;
+  get bytes() {
+    return this.liveBytes;
+  }
+  push(value, getBytes) {
+    if (this.closed) {
+      return {
+        ok: false,
+        reason: "queue_overflow",
+        liveSize: this.liveCount,
+        liveBytes: this.liveBytes
+      };
+    }
     const r = this.resolvers.shift();
     if (r) {
       r({ value, done: false });
-      return true;
+      return {
+        ok: true,
+        liveSize: this.liveCount,
+        liveBytes: this.liveBytes
+      };
+    }
+    if (this.liveCount >= this.maxSize) {
+      return {
+        ok: false,
+        reason: "queue_overflow",
+        liveSize: this.liveCount,
+        liveBytes: this.liveBytes
+      };
     }
-    if (this.liveCount >= this.maxSize) return false;
-    this.buf.push({ value, forced: false });
+    const bytes = getBytes();
+    if (this.liveCount > 0 && this.liveBytes + bytes > this.maxBytes) {
+      return {
+        ok: false,
+        reason: "queue_bytes_overflow",
+        liveSize: this.liveCount,
+        liveBytes: this.liveBytes,
+        eventBytes: bytes
+      };
+    }
+    this.buf.push({ value, forced: false, bytes });
     this.liveCount += 1;
-    return true;
+    this.liveBytes += bytes;
+    return {
+      ok: true,
+      liveSize: this.liveCount,
+      liveBytes: this.liveBytes
+    };
   }
   /** Bypasses the size cap. Used for replay frames, eviction terminal,
    * and slow-client warnings. */
@@ -316,7 +471,7 @@ var BoundedAsyncQueue = class {
       r({ value, done: false });
       return;
     }
-    this.buf.push({ value, forced: true });
+    this.buf.push({ value, forced: true, bytes: 0 });
   }
   /**
    * Mark the queue closed. By default `next()` continues to drain
@@ -338,6 +493,7 @@ var BoundedAsyncQueue = class {
     if (opts.drain === false) {
       this.buf.length = 0;
       this.liveCount = 0;
+      this.liveBytes = 0;
     }
     while (this.resolvers.length > 0) {
       this.resolvers.shift()({
@@ -349,7 +505,10 @@ var BoundedAsyncQueue = class {
   next() {
     if (this.buf.length > 0) {
       const entry = this.buf.shift();
-      if (!entry.forced) this.liveCount -= 1;
+      if (!entry.forced) {
+        this.liveCount -= 1;
+        this.liveBytes -= entry.bytes;
+      }
       return Promise.resolve({ value: entry.value, done: false });
     }
     if (this.closed) {

package/chunks/{chunk-2INJBYLJ.js → chunk-GIY6JTTC.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   loadSettings
-} from "./chunk-CEYA7K7C.js";
+} from "./chunk-QHT5USLK.js";
 import {
   getCurrentLanguage
-} from "./chunk-6QVRLKTZ.js";
+} from "./chunk-TBLJNMI7.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-V6NH3CUC.js";
+} from "./chunk-MOQOAH7N.js";
 import {
   writeStderrLine,
   writeStdoutLine
@@ -26,14 +26,14 @@ import {
   hashMcpServerConfig,
   isGatedMcpScope,
   normalizeClaudeMcpServer
-} from "./chunk-AGZF43UV.js";
+} from "./chunk-E7HM76PR.js";
 import {
   atomicWriteFile
-} from "./chunk-T42ACHFI.js";
+} from "./chunk-7LTB54MK.js";
 import {
   Storage,
   getErrorMessage
-} from "./chunk-AVQDCKNF.js";
+} from "./chunk-22MNNNXE.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/chunks/{chunk-D5KISTLW.js → chunk-H6EMK6QK.js}

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

package/chunks/{chunk-KYTQOCDE.js → chunk-HW4N45EE.js}

@@ -9,7 +9,7 @@ import {
 
 // packages/core/src/core/tokenLimits.ts
 init_esbuild_shims();
-var DEFAULT_TOKEN_LIMIT = 131072;
+var DEFAULT_TOKEN_LIMIT = 2e5;
 var DEFAULT_OUTPUT_TOKEN_LIMIT = 32e3;
 var ESCALATED_MAX_TOKENS = 64e3;
 function parsePositiveIntegerEnvValue(raw) {
@@ -190,6 +190,12 @@ function hasExplicitOutputLimit(model) {
   return OUTPUT_PATTERNS.some(([regex]) => regex.test(norm));
 }
 __name(hasExplicitOutputLimit, "hasExplicitOutputLimit");
+function escalatedOutputTokenLimit(model, contextWindowSize) {
+  const escalated = Math.max(ESCALATED_MAX_TOKENS, tokenLimit(model, "output"));
+  const window = contextWindowSize !== void 0 && contextWindowSize > 0 ? contextWindowSize : DEFAULT_TOKEN_LIMIT;
+  return Math.min(escalated, Math.floor(window / 2));
+}
+__name(escalatedOutputTokenLimit, "escalatedOutputTokenLimit");
 function knownTokenLimit(model, type = "input") {
   return findTokenLimit(model, type);
 }
@@ -202,6 +208,14 @@ __name(tokenLimit, "tokenLimit");
 // packages/core/src/core/openaiContentGenerator/constants.ts
 init_esbuild_shims();
 var DEFAULT_TIMEOUT = 12e4;
+var DISABLED_REQUEST_TIMEOUT_MS = 2147483647;
+function resolveRequestTimeout(timeout) {
+  if (timeout === void 0 || timeout === null) {
+    return DEFAULT_TIMEOUT;
+  }
+  return timeout <= 0 ? DISABLED_REQUEST_TIMEOUT_MS : timeout;
+}
+__name(resolveRequestTimeout, "resolveRequestTimeout");
 var DEFAULT_STREAM_IDLE_TIMEOUT_MS = 24e4;
 var QWEN_STREAM_IDLE_TIMEOUT_MS_ENV = "QWEN_STREAM_IDLE_TIMEOUT_MS";
 var MAX_STREAM_IDLE_TIMEOUT_MS = 2147483647;
@@ -210,49 +224,6 @@ var DEFAULT_OPENAI_BASE_URL = "https://api.openai.com/v1";
 var DEFAULT_DASHSCOPE_BASE_URL = "https://dashscope.aliyuncs.com/compatible-mode/v1";
 var DASHSCOPE_PROXY_BASE_URL = process.env["DASHSCOPE_PROXY_BASE_URL"];
 
-// packages/core/src/utils/request-tokenizer/textTokenizer.ts
-init_esbuild_shims();
-var TextTokenizer = class {
-  static {
-    __name(this, "TextTokenizer");
-  }
-  /**
-   * Calculate tokens for text content
-   *
-   * @param text - The text to estimate tokens for
-   * @returns The estimated token count
-   */
-  async calculateTokens(text) {
-    return this.calculateTokensSync(text);
-  }
-  /**
-   * Calculate tokens for multiple text strings
-   *
-   * @param texts - Array of text strings to estimate tokens for
-   * @returns Array of token counts corresponding to each input text
-   */
-  async calculateTokensBatch(texts) {
-    return texts.map((text) => this.calculateTokensSync(text));
-  }
-  calculateTokensSync(text) {
-    if (!text || text.length === 0) {
-      return 0;
-    }
-    let asciiChars = 0;
-    let nonAsciiChars = 0;
-    for (let i = 0; i < text.length; i++) {
-      const charCode = text.charCodeAt(i);
-      if (charCode < 128) {
-        asciiChars++;
-      } else {
-        nonAsciiChars++;
-      }
-    }
-    const tokens = asciiChars / 4 + nonAsciiChars * 1.1;
-    return Math.ceil(tokens);
-  }
-};
-
 // packages/core/src/utils/request-tokenizer/supportedImageFormats.ts
 init_esbuild_shims();
 var SUPPORTED_IMAGE_MIME_TYPES = [
@@ -290,9 +261,10 @@ export {
   parsePositiveIntegerEnvValue,
   normalize,
   hasExplicitOutputLimit,
+  escalatedOutputTokenLimit,
   knownTokenLimit,
   tokenLimit,
-  DEFAULT_TIMEOUT,
+  resolveRequestTimeout,
   DEFAULT_STREAM_IDLE_TIMEOUT_MS,
   QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,
   MAX_STREAM_IDLE_TIMEOUT_MS,
@@ -300,7 +272,6 @@ export {
   DEFAULT_OPENAI_BASE_URL,
   DEFAULT_DASHSCOPE_BASE_URL,
   DASHSCOPE_PROXY_BASE_URL,
-  TextTokenizer,
   SUPPORTED_IMAGE_MIME_TYPES,
   isSupportedImageMimeType,
   getSupportedImageFormatsString,

package/chunks/{chunk-VXGPYF7U.js → chunk-IFEWJXFS.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   themeManager
-} from "./chunk-HTWHAN44.js";
+} from "./chunk-PC4ZXHU2.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";