@qwen-code/qwen-code 0.21.9 → 0.21.10

package/chunks/{chunk-MTCYGTWH.js → chunk-KID7K6H2.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   loadSettings
-} from "./chunk-JUWS2Z5K.js";
+} from "./chunk-ABVRJU3D.js";
 import {
   getCurrentLanguage
-} from "./chunk-WP5VOXF7.js";
+} from "./chunk-UEOKWYGY.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-ZOSTTOUJ.js";
+} from "./chunk-GWVUR3QZ.js";
 import {
   require_strip_json_comments
 } from "./chunk-NPQ5ZKRP.js";
@@ -23,7 +23,7 @@ import {
   isGatedMcpScope,
   normalizeClaudeMcpServer,
   runWithTimeout
-} from "./chunk-XX7QFP34.js";
+} from "./chunk-EI3NWELG.js";
 import {
   atomicWriteFile
 } from "./chunk-FOGU3LJX.js";

package/chunks/{chunk-DGEIYUC3.js → chunk-KM73TBQ4.js}

@@ -64,11 +64,17 @@ function clampReasoningEffort(requested, supported) {
   return ranked[ranked.length - 1];
 }
 __name(clampReasoningEffort, "clampReasoningEffort");
+function applyReasoningEffort(config, effort) {
+  config.setReasoningEffort(effort);
+  return config.getReasoningEffort() === effort;
+}
+__name(applyReasoningEffort, "applyReasoningEffort");
 
 export {
   REASONING_EFFORT_TIERS,
   normalizeReasoningEffort,
-  clampReasoningEffort
+  clampReasoningEffort,
+  applyReasoningEffort
 };
 /**
  * @license

package/chunks/{chunk-TZ6KJ44L.js → chunk-KONVMRK7.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   runExitCleanup
-} from "./chunk-PNBBJOCP.js";
+} from "./chunk-AAE6SR4Q.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{scheduler-YNQNOU2E.js → chunk-KZ22NXBY.js}

@@ -5,89 +5,18 @@ import {
 } from "./chunk-KW7NOTN6.js";
 import {
   DEFAULT_OPENAI_LOG_RETENTION_DAYS
-} from "./chunk-7GOYZQPR.js";
-import "./chunk-5EJZE3FP.js";
+} from "./chunk-UBX6NL47.js";
 import {
   FILE_HISTORY_DIR,
   getSubagentsRootDir
-} from "./chunk-XX7QFP34.js";
-import "./chunk-GOFAQQZA.js";
-import "./chunk-5M6IDOMF.js";
-import "./chunk-TWPJO254.js";
-import "./chunk-H6XPXXMH.js";
-import "./chunk-2UUMVNYT.js";
-import "./chunk-MVUQRLOH.js";
-import "./chunk-XCWO3SMQ.js";
-import "./chunk-7MH4J33A.js";
-import "./chunk-6PVPNMXU.js";
-import "./chunk-K4ADGWHU.js";
-import "./chunk-IRH27ZC2.js";
-import "./chunk-QHWCP53L.js";
-import "./chunk-GNPNYXJB.js";
-import "./chunk-HUWENAHO.js";
-import "./chunk-O6GEWCJA.js";
-import "./chunk-T26EAKDL.js";
-import "./chunk-ZPJWUGCS.js";
-import "./chunk-CPBF7KYF.js";
-import "./chunk-J6SZID63.js";
-import "./chunk-KRXPRVGL.js";
-import "./chunk-GM463R2B.js";
-import "./chunk-SEZ556DZ.js";
-import "./chunk-2FRY5CRX.js";
-import "./chunk-67N6HB5H.js";
-import "./chunk-WAUGQKUU.js";
+} from "./chunk-EI3NWELG.js";
 import {
   resolveOpenAILogDir
 } from "./chunk-DZUO626D.js";
-import "./chunk-4TRQPFDP.js";
-import "./chunk-SAH4BD2J.js";
-import "./chunk-CPG6P4GG.js";
-import "./chunk-S6LOFUVP.js";
-import "./chunk-2J3OJGTL.js";
-import "./chunk-IA7TGCN2.js";
-import "./chunk-K623ENWT.js";
-import "./chunk-AQ37AY7B.js";
-import "./chunk-EQL65XGA.js";
-import "./chunk-3P2LV43B.js";
-import "./chunk-NAVJD2PQ.js";
-import "./chunk-HV76SFIA.js";
-import "./chunk-4PYCZH2V.js";
-import "./chunk-P3QQPMQA.js";
-import "./chunk-SR7RZ4MS.js";
-import "./chunk-M6HMMKVG.js";
-import "./chunk-DGEIYUC3.js";
-import "./chunk-MPHPFVKK.js";
-import "./chunk-AXMWHKXA.js";
-import "./chunk-GLCZKT5V.js";
-import "./chunk-DJ2GSRLV.js";
-import "./chunk-EI3HZX6C.js";
-import "./chunk-YGT2AUJ7.js";
-import "./chunk-WOJZWRAZ.js";
-import "./chunk-VGC4I5JJ.js";
-import "./chunk-FVKHVJZQ.js";
-import "./chunk-COBO5EBO.js";
-import "./chunk-6ZRFAKXK.js";
-import "./chunk-PYQADEFD.js";
-import "./chunk-PVOGHGSF.js";
-import "./chunk-F6WFNA7U.js";
-import "./chunk-46UV252V.js";
-import "./chunk-ZBVS26BY.js";
-import "./chunk-KKBPOU75.js";
-import "./chunk-EUNWC2VS.js";
-import "./chunk-FOGU3LJX.js";
-import "./chunk-L2AFWWJE.js";
-import "./chunk-W4RQUHY3.js";
-import "./chunk-PDPFQ2FO.js";
 import {
   Storage,
   createDebugLogger
 } from "./chunk-OIVKILPI.js";
-import "./chunk-VOQXFAY5.js";
-import "./chunk-75DOP5OR.js";
-import "./chunk-DMTGGOSA.js";
-import "./chunk-YQ3U5MUC.js";
-import "./chunk-AMDSOFFV.js";
-import "./chunk-QUGAUQGJ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -167,7 +96,15 @@ async function cleanupOldSubagentTranscripts(opts) {
 __name(cleanupOldSubagentTranscripts, "cleanupOldSubagentTranscripts");
 var OPENAI_LOG_FILE_PATTERN = /^openai-(\d{4}-\d{2}-\d{2})T\d{2}-\d{2}-\d{2}\.\d{3}Z-[a-f0-9]{8}(?:-[a-zA-Z0-9._](?:[a-zA-Z0-9._-]*[a-zA-Z0-9._])?)?\.json$/;
 async function cleanupOldOpenAILogs(opts) {
-  const result = { removed: 0, errors: 0 };
+  const result = {
+    removed: 0,
+    errors: 0,
+    completed: true
+  };
+  if (opts.signal?.aborted) {
+    result.completed = false;
+    return result;
+  }
   let dir;
   try {
     dir = await opendir(opts.logDir);
@@ -179,6 +116,10 @@ async function cleanupOldOpenAILogs(opts) {
   const cutoffDay = opts.cutoffDate.toISOString().slice(0, 10);
   let batch = [];
   for await (const entry of dir) {
+    if (opts.signal?.aborted) {
+      result.completed = false;
+      break;
+    }
     const filenameDate = entry.isFile() ? OPENAI_LOG_FILE_PATTERN.exec(entry.name)?.[1] : void 0;
     if (!filenameDate) continue;
     const filePath = join(opts.logDir, entry.name);
@@ -231,8 +172,13 @@ async function runThrottledOnce(opts, task) {
     () => {
     }
   );
-  if (await markerIsFresh(opts.markerPath, minIntervalMs, opts.name)) {
-    return false;
+  const firstFreshForMs = await markerFreshForMs(
+    opts.markerPath,
+    minIntervalMs,
+    opts.name
+  );
+  if (firstFreshForMs !== void 0) {
+    return { status: "fresh", retryAfterMs: firstFreshForMs };
   }
   let acquired = await tryAcquire(opts.lockPath);
   if (!acquired) {
@@ -248,17 +194,21 @@ async function runThrottledOnce(opts, task) {
     }
     if (!acquired) {
       debugLogger2.debug(`${opts.name}: skipping, lock held`);
-      return false;
+      return { status: "locked" };
     }
   }
   try {
-    if (await markerIsFresh(opts.markerPath, minIntervalMs, opts.name)) {
-      return false;
+    const secondFreshForMs = await markerFreshForMs(
+      opts.markerPath,
+      minIntervalMs,
+      opts.name
+    );
+    if (secondFreshForMs !== void 0) {
+      return { status: "fresh", retryAfterMs: secondFreshForMs };
     }
     let taskCompleted = false;
     try {
-      await task();
-      taskCompleted = true;
+      taskCompleted = await task() !== false;
     } finally {
       if (taskCompleted) {
         try {
@@ -271,7 +221,7 @@ async function runThrottledOnce(opts, task) {
         }
       }
     }
-    return taskCompleted;
+    return { status: taskCompleted ? "completed" : "incomplete" };
   } finally {
     await unlink2(opts.lockPath).catch(() => {
       debugLogger2.debug(`${opts.name}: lock unlink failed (harmless)`);
@@ -279,19 +229,19 @@ async function runThrottledOnce(opts, task) {
   }
 }
 __name(runThrottledOnce, "runThrottledOnce");
-async function markerIsFresh(markerPath, minIntervalMs, name) {
+async function markerFreshForMs(markerPath, minIntervalMs, name) {
   try {
     const s = await stat2(markerPath);
     const age = Date.now() - s.mtimeMs;
     if (age < minIntervalMs) {
       debugLogger2.debug(`${name}: skipping, ran ${age}ms ago`);
-      return true;
+      return minIntervalMs - age;
     }
   } catch {
   }
-  return false;
+  return void 0;
 }
-__name(markerIsFresh, "markerIsFresh");
+__name(markerFreshForMs, "markerFreshForMs");
 async function tryAcquire(lockPath) {
   try {
     const fh = await open(lockPath, "wx");
@@ -313,10 +263,20 @@ var RECURRING_INTERVAL_MS = 24 * 60 * 60 * 1e3;
 var RECENT_INTERACTION_MS = 60 * 1e3;
 var CATCHUP_THRESHOLD_MS = 7 * 24 * 60 * 60 * 1e3;
 var STARTUP_DELAY_CATCHUP_MS = 60 * 1e3;
+var NON_INTERACTIVE_LOCK_RETRY_MS = 60 * 1e3;
+var NON_INTERACTIVE_FAILURE_RETRY_MS = 10 * 60 * 1e3;
+var NON_INTERACTIVE_STOP_GRACE_MS = 250;
 var FILE_HISTORY_MARKER = ".file-history-cleanup";
 var SUBAGENT_MARKER = ".subagent-cleanup";
 var OPENAI_LOGS_MARKER = ".openai-logs-cleanup";
 var started = false;
+var nonInteractiveJobs = /* @__PURE__ */ new Map();
+var nonInteractiveQueue = [];
+var activeNonInteractiveJob;
+var activeNonInteractiveAbortController;
+var nonInteractiveWorker;
+var nonInteractiveStopping = false;
+var nonInteractiveStopPromise;
 function startBackgroundHousekeeping(config, settings) {
   if (started) return;
   started = true;
@@ -367,7 +327,7 @@ function getOpenAILogsMarkerPath(qwenDir, logDir) {
 __name(getOpenAILogsMarkerPath, "getOpenAILogsMarkerPath");
 function getOpenAILogCleanupTarget(config, settings) {
   try {
-    const customLogDir = config.getContentGeneratorConfig?.()?.openAILoggingDir ?? settings.merged.model?.openAILoggingDir;
+    const customLogDir = config.getContentGeneratorConfig?.()?.openAILoggingDir ?? config.getModelsConfig?.()?.getGenerationConfig?.().openAILoggingDir ?? settings.merged.model?.openAILoggingDir;
     const systemRetention = settings.system?.settings.model?.openAILogRetentionDays;
     const workspaceRetention = settings.isTrusted ? settings.workspace?.settings.model?.openAILogRetentionDays : void 0;
     if (customLogDir && workspaceRetention !== void 0 && systemRetention === void 0) {
@@ -390,6 +350,168 @@ function getOpenAILogCleanupTarget(config, settings) {
   }
 }
 __name(getOpenAILogCleanupTarget, "getOpenAILogCleanupTarget");
+function startNonInteractiveOpenAILogHousekeeping(config, settings) {
+  if (nonInteractiveStopping) return;
+  try {
+    const target = getOpenAILogCleanupTarget(config, settings);
+    if (!target || nonInteractiveJobs.has(target.logDir)) return;
+    const markerPath = getOpenAILogsMarkerPath(
+      Storage.getGlobalQwenDir(),
+      target.logDir
+    );
+    const job = {
+      target,
+      markerPath,
+      queued: false
+    };
+    nonInteractiveJobs.set(target.logDir, job);
+    enqueueNonInteractiveJob(job);
+  } catch (err) {
+    debugLogger3.error(
+      "failed to start non-interactive OpenAI log cleanup; skipping",
+      err
+    );
+  }
+}
+__name(startNonInteractiveOpenAILogHousekeeping, "startNonInteractiveOpenAILogHousekeeping");
+function stopNonInteractiveOpenAILogHousekeeping() {
+  if (nonInteractiveStopPromise) return nonInteractiveStopPromise;
+  nonInteractiveStopping = true;
+  for (const job of nonInteractiveJobs.values()) {
+    if (job.timer) {
+      clearTimeout(job.timer);
+      job.timer = void 0;
+    }
+    job.queued = false;
+  }
+  nonInteractiveQueue.length = 0;
+  activeNonInteractiveAbortController?.abort();
+  nonInteractiveStopPromise = waitForNonInteractiveWorkerToStop();
+  return nonInteractiveStopPromise;
+}
+__name(stopNonInteractiveOpenAILogHousekeeping, "stopNonInteractiveOpenAILogHousekeeping");
+function enqueueNonInteractiveJob(job) {
+  if (nonInteractiveStopping || job.queued || activeNonInteractiveJob === job) {
+    return;
+  }
+  job.queued = true;
+  nonInteractiveQueue.push(job);
+  startNonInteractiveWorker();
+}
+__name(enqueueNonInteractiveJob, "enqueueNonInteractiveJob");
+function startNonInteractiveWorker() {
+  if (nonInteractiveWorker || nonInteractiveStopping) return;
+  nonInteractiveWorker = drainNonInteractiveQueue().catch((err) => {
+    debugLogger3.error("non-interactive OpenAI log worker failed", err);
+  }).finally(() => {
+    nonInteractiveWorker = void 0;
+    if (nonInteractiveQueue.length > 0 && !nonInteractiveStopping) {
+      startNonInteractiveWorker();
+    }
+  });
+}
+__name(startNonInteractiveWorker, "startNonInteractiveWorker");
+async function drainNonInteractiveQueue() {
+  while (!nonInteractiveStopping) {
+    const job = nonInteractiveQueue.shift();
+    if (!job) return;
+    job.queued = false;
+    activeNonInteractiveJob = job;
+    const abortController = new AbortController();
+    activeNonInteractiveAbortController = abortController;
+    try {
+      const result = await runOpenAILogCleanup(
+        job.target,
+        job.markerPath,
+        abortController.signal
+      );
+      if (nonInteractiveStopping) continue;
+      switch (result.status) {
+        case "completed":
+          scheduleNonInteractiveJob(job, RECURRING_INTERVAL_MS);
+          break;
+        case "fresh":
+          scheduleNonInteractiveJob(
+            job,
+            Math.min(
+              RECURRING_INTERVAL_MS,
+              Math.max(NON_INTERACTIVE_LOCK_RETRY_MS, result.retryAfterMs)
+            )
+          );
+          break;
+        case "locked":
+          scheduleNonInteractiveJob(job, NON_INTERACTIVE_LOCK_RETRY_MS);
+          break;
+        case "incomplete":
+          break;
+        default:
+          break;
+      }
+    } catch (err) {
+      debugLogger3.error(
+        `non-interactive OpenAI log cleanup failed for ${job.target.logDir}`,
+        err
+      );
+      if (!nonInteractiveStopping) {
+        scheduleNonInteractiveJob(job, NON_INTERACTIVE_FAILURE_RETRY_MS);
+      }
+    } finally {
+      activeNonInteractiveJob = void 0;
+      activeNonInteractiveAbortController = void 0;
+    }
+  }
+}
+__name(drainNonInteractiveQueue, "drainNonInteractiveQueue");
+async function runOpenAILogCleanup(target, markerPath, signal) {
+  return runThrottledOnce(
+    {
+      name: "openai-logs-cleanup",
+      markerPath,
+      lockPath: markerPath + ".lock"
+    },
+    async () => {
+      const r = await cleanupOldOpenAILogs({
+        logDir: target.logDir,
+        cutoffDate: getCutoffDate(target.retentionDays),
+        signal
+      });
+      debugLogger3.debug(
+        `openai-logs: removed=${r.removed} errors=${r.errors} completed=${r.completed}`
+      );
+      return r.completed ? void 0 : false;
+    }
+  );
+}
+__name(runOpenAILogCleanup, "runOpenAILogCleanup");
+function scheduleNonInteractiveJob(job, delayMs) {
+  if (nonInteractiveStopping) return;
+  job.timer = setTimeout(() => {
+    job.timer = void 0;
+    enqueueNonInteractiveJob(job);
+  }, delayMs);
+  job.timer.unref();
+}
+__name(scheduleNonInteractiveJob, "scheduleNonInteractiveJob");
+async function waitForNonInteractiveWorkerToStop() {
+  const worker = nonInteractiveWorker;
+  if (!worker) {
+    nonInteractiveJobs.clear();
+    return;
+  }
+  let timeout;
+  try {
+    await Promise.race([
+      worker,
+      new Promise((resolve) => {
+        timeout = setTimeout(resolve, NON_INTERACTIVE_STOP_GRACE_MS);
+      })
+    ]);
+  } finally {
+    if (timeout) clearTimeout(timeout);
+    nonInteractiveJobs.clear();
+  }
+}
+__name(waitForNonInteractiveWorkerToStop, "waitForNonInteractiveWorkerToStop");
 async function runPass(config, settings) {
   if (msSinceLastInteraction() < RECENT_INTERACTION_MS) {
     debugLogger3.debug("user active, deferring 10 min");
@@ -458,23 +580,9 @@ async function runHousekeeping(config, settings) {
   }
   const openaiTarget = getOpenAILogCleanupTarget(config, settings);
   if (openaiTarget) {
-    const { logDir, retentionDays } = openaiTarget;
-    const markerPath = getOpenAILogsMarkerPath(qwenDir, logDir);
-    await runThrottledOnce(
-      {
-        name: "openai-logs-cleanup",
-        markerPath,
-        lockPath: markerPath + ".lock"
-      },
-      async () => {
-        const r = await cleanupOldOpenAILogs({
-          logDir,
-          cutoffDate: getCutoffDate(retentionDays)
-        });
-        debugLogger3.debug(
-          `openai-logs: removed=${r.removed} errors=${r.errors}`
-        );
-      }
+    await runOpenAILogCleanup(
+      openaiTarget,
+      getOpenAILogsMarkerPath(qwenDir, openaiTarget.logDir)
     );
   }
 }
@@ -483,6 +591,22 @@ function _resetForTesting() {
   started = false;
 }
 __name(_resetForTesting, "_resetForTesting");
+async function _resetNonInteractiveForTesting() {
+  nonInteractiveStopping = true;
+  for (const job of nonInteractiveJobs.values()) {
+    if (job.timer) clearTimeout(job.timer);
+  }
+  nonInteractiveQueue.length = 0;
+  activeNonInteractiveAbortController?.abort();
+  await nonInteractiveWorker;
+  nonInteractiveJobs.clear();
+  activeNonInteractiveJob = void 0;
+  activeNonInteractiveAbortController = void 0;
+  nonInteractiveWorker = void 0;
+  nonInteractiveStopping = false;
+  nonInteractiveStopPromise = void 0;
+}
+__name(_resetNonInteractiveForTesting, "_resetNonInteractiveForTesting");
 var _needsCatchUpForTesting = needsCatchUp;
 var _getFirstPassDelayForTesting = getFirstPassDelay;
 var _runHousekeepingForTesting = runHousekeeping;
@@ -490,16 +614,20 @@ var _runPassForTesting = runPass;
 var _FILE_HISTORY_MARKER_FOR_TESTING = FILE_HISTORY_MARKER;
 var _getSubagentMarkerPathForTesting = getSubagentMarkerPath;
 var _getOpenAILogsMarkerPathForTesting = getOpenAILogsMarkerPath;
+
 export {
-  _FILE_HISTORY_MARKER_FOR_TESTING,
-  _getFirstPassDelayForTesting,
-  _getOpenAILogsMarkerPathForTesting,
-  _getSubagentMarkerPathForTesting,
-  _needsCatchUpForTesting,
+  startBackgroundHousekeeping,
+  startNonInteractiveOpenAILogHousekeeping,
+  stopNonInteractiveOpenAILogHousekeeping,
   _resetForTesting,
+  _resetNonInteractiveForTesting,
+  _needsCatchUpForTesting,
+  _getFirstPassDelayForTesting,
   _runHousekeepingForTesting,
   _runPassForTesting,
-  startBackgroundHousekeeping
+  _FILE_HISTORY_MARKER_FOR_TESTING,
+  _getSubagentMarkerPathForTesting,
+  _getOpenAILogsMarkerPathForTesting
 };
 /**
  * @license

package/chunks/{chunk-RBHQXGDK.js → chunk-LLCWZQCU.js}

@@ -5,7 +5,7 @@ import {
   isTranscribableVoiceModel,
   readVoiceLanguage,
   resolveVoiceTransport
-} from "./chunk-GAKGOXTC.js";
+} from "./chunk-EBZ6BJTF.js";
 import {
   resolvePath
 } from "./chunk-AOHJKPKL.js";