@qwen-code/qwen-code 0.19.10 → 0.19.11-nightly.20260717.f8e6e8931

package/chunks/{chunk-E67NFMF4.js → chunk-A2HWMJVO.js}

@@ -22,7 +22,7 @@ import {
 } from "./chunk-SPJQO2CE.js";
 import {
   ToolNames
-} from "./chunk-2UUAIFQO.js";
+} from "./chunk-JGUT3LWZ.js";
 import {
   Storage,
   createDebugLogger,
@@ -331,6 +331,11 @@ var CronScheduler = class {
   fileWatcher = null;
   lockProbeTimer = null;
   debounceTimer = null;
+  // Test-only auto-fire timers (QWEN_CODE_TEST_CRON_FAST). Each timer
+  // fires its job via forceFireJob after a short delay so integration
+  // tests don't wait for the wall-clock minute boundary. Cleared on
+  // stop()/destroy() so a session teardown never leaks a pending fire.
+  testFireTimers = /* @__PURE__ */ new Map();
   // Catch-up work detected before start() installed onFire — flushed
   // through onFire as soon as it exists.
   pendingFires = [];
@@ -366,6 +371,18 @@ var CronScheduler = class {
       jitterMs
     };
     this.jobs.set(id, job);
+    if (process.env["QWEN_CODE_TEST_CRON_FAST"] === "1" && !job.durable) {
+      const delayMs = Number(process.env["QWEN_CODE_TEST_CRON_DELAY_MS"]) || 5e3;
+      const timer = setTimeout(() => {
+        this.testFireTimers.delete(id);
+        this.forceFireJob(id);
+      }, delayMs);
+      timer.unref();
+      this.testFireTimers.set(id, timer);
+      debugLogger.debug(
+        `Test seam: auto-fire scheduled for job ${id} in ${delayMs}ms`
+      );
+    }
     return job;
   }
   /**
@@ -887,6 +904,21 @@ var CronScheduler = class {
   setSkipDurableFire(predicate) {
     this.skipDurableFire = predicate;
   }
+  /**
+   * Immediately fires a job by ID, bypassing the cron schedule check.
+   * Sets lastFiredAt to prevent the normal tick from re-firing the same
+   * minute slot. Returns true if the job existed and was fired, false
+   * otherwise. Primarily a test seam (see QWEN_CODE_TEST_CRON_FAST in
+   * create()); also useful for manual debug triggers.
+   */
+  forceFireJob(id) {
+    const job = this.jobs.get(id);
+    if (!job || !this.onFire) return false;
+    job.lastFiredAt = Date.now();
+    debugLogger.debug(`forceFireJob: firing ${id} (${job.cronExpr})`);
+    this.onFire(job);
+    return true;
+  }
   /**
    * Starts the scheduler tick. Calls `onFire` when a job is due.
    * Only fires when called — does not auto-fire missed intervals.
@@ -926,6 +958,8 @@ var CronScheduler = class {
       clearTimeout(this.debounceTimer);
       this.debounceTimer = null;
     }
+    for (const timer of this.testFireTimers.values()) clearTimeout(timer);
+    this.testFireTimers.clear();
     if (this.wakeups.size > 0) {
       debugLogger.debug(`stop() discarding ${this.wakeups.size} wakeup(s)`);
       this.wakeups.clear();

package/chunks/{chunk-4FMG7EDJ.js → chunk-AEKHQ3E5.js}

@@ -3,7 +3,10 @@
 import {
   formatHistoryGapNotice,
   indexGapsByChild
-} from "./chunk-SPUYQB4T.js";
+} from "./chunk-DPXB3XRN.js";
+import {
+  sanitizeTerminalText
+} from "./chunk-SUARMD4Q.js";
 import {
   require_undici
 } from "./chunk-L573Z2QZ.js";
@@ -12,13 +15,15 @@ import {
 } from "./chunk-YUZI3WAC.js";
 import {
   getActiveGoal
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-R6AO7HBQ.js";
 import {
-  apiActivityTracker
-} from "./chunk-P6LART6G.js";
+  apiActivityTracker,
+  formatVisionBridgeNoticeDisplay,
+  isVisionBridgeNoticeDisplay
+} from "./chunk-BTSE2DUP.js";
 import {
   ToolNames
-} from "./chunk-2UUAIFQO.js";
+} from "./chunk-JGUT3LWZ.js";
 import {
   createDebugLogger
 } from "./chunk-7NFB7LBQ.js";
@@ -826,6 +831,7 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
     __name(this, "ToolCallEmitter");
   }
   planEmitter;
+  preparedCallIds = /* @__PURE__ */ new Set();
   constructor(ctx) {
     super(ctx);
     this.planEmitter = new PlanEmitter(ctx);
@@ -840,6 +846,9 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
     if (this.isTodoWriteTool(params.toolName)) {
       return false;
     }
+    if (params.phase === "preparing" && this.preparedCallIds.has(params.callId)) {
+      return false;
+    }
     const { title, locations, kind } = this.resolveToolMetadata(
       params.toolName,
       params.args
@@ -848,8 +857,8 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
       params.toolName,
       params.subagentMeta
     );
-    await this.sendUpdate({
-      sessionUpdate: "tool_call",
+    const updatesPreparedCall = params.phase !== "preparing" && this.preparedCallIds.delete(params.callId);
+    const update = {
       toolCallId: params.callId,
       status: params.status || "pending",
       title,
@@ -859,6 +868,7 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
       rawInput: params.args ?? {},
       _meta: {
         toolName: params.toolName,
+        ...params.phase ? { phase: params.phase } : {},
         ...params.subagentMeta,
         provenance: provenance.provenance,
         ...provenance.serverId ? { serverId: provenance.serverId } : {},
@@ -866,9 +876,40 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
           timestamp: BaseEmitter.toEpochMs(params.timestamp)
         }
       }
-    });
+    };
+    await this.sendUpdate(
+      updatesPreparedCall ? { sessionUpdate: "tool_call_update", ...update } : { sessionUpdate: "tool_call", ...update }
+    );
+    if (params.phase === "preparing") {
+      this.preparedCallIds.add(params.callId);
+    }
     return true;
   }
+  /**
+   * Emits a terminal frame when a prepared tool call is discarded before
+   * execution. TodoWrite remains represented exclusively by plan updates.
+   *
+   * @param callId - ID of the prepared tool call
+   * @param toolName - Name of the prepared tool
+   */
+  async emitPreparationDiscarded(callId, toolName) {
+    if (this.isTodoWriteTool(toolName)) return;
+    this.preparedCallIds.delete(callId);
+    const provenance = _ToolCallEmitter.resolveToolProvenance(toolName);
+    await this.sendUpdate({
+      sessionUpdate: "tool_call_update",
+      toolCallId: callId,
+      status: "failed",
+      content: [],
+      _meta: {
+        toolName,
+        phase: "preparing",
+        preparationDiscarded: true,
+        provenance: provenance.provenance,
+        ...provenance.serverId ? { serverId: provenance.serverId } : {}
+      }
+    });
+  }
   /**
    * Emits a tool call result event.
    * Handles TodoWriteTool specially by routing to plan updates.
@@ -888,6 +929,7 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
       }
       return;
     }
+    this.preparedCallIds.delete(params.callId);
     let contentArray = [];
     const diffContent = this.extractDiffContent(params.resultDisplay);
     if (diffContent) {
@@ -902,6 +944,17 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
     } else {
       contentArray = this.transformPartsToToolCallContent(params.message);
     }
+    if (isVisionBridgeNoticeDisplay(params.resultDisplay)) {
+      contentArray.unshift({
+        type: "content",
+        content: {
+          type: "text",
+          text: sanitizeTerminalText(
+            formatVisionBridgeNoticeDisplay(params.resultDisplay)
+          )
+        }
+      });
+    }
     const provenance = _ToolCallEmitter.resolveToolProvenance(
       params.toolName,
       params.subagentMeta
@@ -937,6 +990,7 @@ var ToolCallEmitter = class _ToolCallEmitter extends BaseEmitter {
    * @param subagentMeta - Optional subagent metadata
    */
   async emitError(callId, toolName, error, subagentMeta) {
+    this.preparedCallIds.delete(callId);
     const provenance = _ToolCallEmitter.resolveToolProvenance(
       toolName,
       subagentMeta
@@ -1384,7 +1438,7 @@ var HistoryReplayer = class {
     await this.toolCallEmitter.emitResult({
       toolName,
       callId,
-      success: !result?.error,
+      success: result?.status === void 0 ? !result?.error : result.status === "success" && !result.error,
       message: record.message.parts,
       resultDisplay: result?.resultDisplay,
       artifacts: result?.artifacts,
@@ -1681,7 +1735,7 @@ async function extractMetadata(conversation, config) {
   const gitBranch = firstRecord?.gitBranch;
   let gitRepo;
   if (cwd) {
-    const { getGitRepoName } = await import("./src-USZKPUOC.js");
+    const { getGitRepoName } = await import("./src-6OJFUPTL.js");
     gitRepo = getGitRepoName(cwd);
   }
   let model;
@@ -1996,7 +2050,19 @@ function buildToolCallMessageFromResult(record, config) {
   const rawInput = normalizeRawInput(
     functionCallArgs ?? toolCallResult?.args
   );
-  const content = extractDiffContent(toolCallResult?.resultDisplay) ?? transformPartsToToolCallContent(record.message?.parts ?? []);
+  const resultContent = extractDiffContent(toolCallResult?.resultDisplay) ?? transformPartsToToolCallContent(record.message?.parts ?? []);
+  const content = isVisionBridgeNoticeDisplay(toolCallResult?.resultDisplay) ? [
+    {
+      type: "content",
+      content: {
+        type: "text",
+        text: sanitizeTerminalText(
+          formatVisionBridgeNoticeDisplay(toolCallResult.resultDisplay)
+        )
+      }
+    },
+    ...resultContent
+  ] : resultContent;
   return {
     uuid: record.uuid,
     parentUuid: record.parentUuid,

package/chunks/{chunk-WIASPMLX.js → chunk-AH3YAJU6.js}

@@ -4,22 +4,22 @@ import {
   handleAtCommand,
   resolveAtCommandQuery,
   sanitizeDisplayText
-} from "./chunk-X362TMXZ.js";
+} from "./chunk-XQDPCQ3A.js";
 import {
   isAtCommand,
   isBtwCommand,
   isSlashCommand,
   normalizePartList,
   recordGoalStatusItem
-} from "./chunk-YX4LLZ3D.js";
+} from "./chunk-NABT4VOY.js";
 import {
   fitPendingSlice,
   useSessionStats
-} from "./chunk-XXJKGHZV.js";
+} from "./chunk-6VMOP2Z7.js";
 import {
   SHELL_COMMAND_NAME,
   isCollapsibleTool
-} from "./chunk-DK33QJ3V.js";
+} from "./chunk-GCRFH57X.js";
 import {
   require_react
 } from "./chunk-HTHUX2T5.js";
@@ -31,10 +31,10 @@ import {
 } from "./chunk-E5Z2AVNV.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-GGJII3FM.js";
+} from "./chunk-WZJELXEU.js";
 import {
   t
-} from "./chunk-RDRVMDWV.js";
+} from "./chunk-EMJJBXS7.js";
 import {
   AutonomousLoopTickResolver,
   CoreToolScheduler,
@@ -48,37 +48,39 @@ import {
   generateToolUseSummary,
   getActiveGoal,
   getToolResponseDisplayText,
-  hasImageParts,
   isBinary,
   markDuplicateProviderToolCallResponseSent,
   parseAndFormatApiError,
   promptIdContext,
   refreshMemoryAfterManagedWrite,
-  runVisionBridge,
-  setActiveGoal,
-  shouldRunVisionBridge,
-  splitImageParts
-} from "./chunk-K7CRWKOE.js";
+  setActiveGoal
+} from "./chunk-R6AO7HBQ.js";
 import {
   ApiCancelEvent,
   ConversationFinishedEvent,
   UserPromptEvent,
   UserRetryEvent,
+  formatVisionBridgeNotice,
+  hasImageParts,
   logApiCancel,
   logConversationFinishedEvent,
   logUserPrompt,
-  logUserRetry
-} from "./chunk-P6LART6G.js";
+  logUserRetry,
+  runVisionBridge,
+  shouldRunVisionBridge,
+  splitImageParts
+} from "./chunk-BTSE2DUP.js";
 import {
   isAnyAutoMemPath
 } from "./chunk-FBU7WRZI.js";
 import {
-  ToolNames
-} from "./chunk-2UUAIFQO.js";
+  ToolNames,
+  isShellProgressData
+} from "./chunk-JGUT3LWZ.js";
 import {
   getUnsupportedImageFormatWarning,
   isSupportedImageMimeType
-} from "./chunk-B7NUUEXC.js";
+} from "./chunk-FEOZBUMT.js";
 import {
   FinishReason
 } from "./chunk-4LD5APFL.js";
@@ -550,6 +552,9 @@ function useReactToolScheduler(onComplete, config, getPreferredEditor, onEditorC
   const [toolCallsForDisplay, setToolCallsForDisplay] = (0, import_react4.useState)([]);
   const outputUpdateHandler = (0, import_react4.useCallback)(
     (toolCallId, outputChunk) => {
+      if (isShellProgressData(outputChunk)) {
+        return;
+      }
       const compactOutput = compactToolResultDisplayForHistory(outputChunk);
       setToolCallsForDisplay(
         (prevCalls) => prevCalls.map((tc) => {
@@ -802,22 +807,6 @@ function clearModelOverride(modelOverrideRef, inlineActiveRef) {
 __name(clearModelOverride, "clearModelOverride");
 var MID_TURN_AT_COMMAND_RESOLVE_TIMEOUT_MS = 1e4;
 var MID_TURN_AT_COMMAND_RESOLVE_TIMEOUT_MESSAGE = "Mid-turn @ command resolution timed out";
-function formatVisionBridgeNotice(result) {
-  const modelName = result.modelId ?? "vision model";
-  const target = result.modelEndpoint ? `${modelName} (${result.modelEndpoint})` : modelName;
-  const egressNote = result.egressOccurred ? ` Your image and prompt/context were sent to ${target}.` : "";
-  if (result.status === "failed") {
-    const reason = result.egressOccurred ? "the vision model request failed" : "the vision bridge could not run";
-    return `Vision bridge (${modelName}) failed: ${reason}.${egressNote} The image was not interpreted.`;
-  }
-  if (result.status === "skipped") {
-    return `Vision bridge cancelled.${egressNote}`;
-  }
-  const omitted = result.omittedCount > 0 ? ` (${result.omittedCount} image(s) omitted)` : "";
-  const header = `Converted ${result.convertedCount} image(s)${omitted} to text via ${target}. Your image and prompt/context were sent to that model.`;
-  return header;
-}
-__name(formatVisionBridgeNotice, "formatVisionBridgeNotice");
 function extractLastAssistantText(history) {
   for (let i = history.length - 1; i >= 0; i--) {
     const item = history[i];

package/chunks/{chunk-6GKMJPOC.js → chunk-AHAH5H6D.js}

@@ -8,16 +8,16 @@ import {
   initializeI18n,
   resolveLanguageSetting,
   t
-} from "./chunk-RDRVMDWV.js";
+} from "./chunk-EMJJBXS7.js";
 import {
   IdeClient
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-R6AO7HBQ.js";
 import {
   AuthEvent,
   IdeConnectionEvent,
   logAuth,
   logIdeConnection
-} from "./chunk-P6LART6G.js";
+} from "./chunk-BTSE2DUP.js";
 import {
   getErrorMessage
 } from "./chunk-7NFB7LBQ.js";

package/chunks/{chunk-3XJFUTNM.js → chunk-AVAU67KP.js}

@@ -2,17 +2,23 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-CEW4HDPK.js";
+} from "./chunk-ZK4AMPKI.js";
+import {
+  CUSTOM_SANDBOX_IMAGE_ENV_VAR,
+  HOST_UPDATE_RELAUNCH_ENV_VAR,
+  SKIP_UPDATE_CHECK_ENV_VAR,
+  requestUpdateOnExit
+} from "./chunk-6WVLHULT.js";
 import {
   require_undici
 } from "./chunk-L573Z2QZ.js";
 import {
   IdeClient,
   getAllProviderBaseUrls
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-R6AO7HBQ.js";
 import {
   initializeTelemetry
-} from "./chunk-P6LART6G.js";
+} from "./chunk-BTSE2DUP.js";
 import {
   detectRuntime,
   getOrCreateSharedDispatcher,
@@ -218,18 +224,20 @@ __name(startEarlyStartupPrefetches, "startEarlyStartupPrefetches");
 function startPostRenderPrefetches(config, settings, options = {}) {
   if (postRenderStarted.has(config)) return;
   postRenderStarted.add(config);
-  if (settings.merged.general?.enableAutoUpdate !== false) {
+  if (settings.merged.general?.enableAutoUpdate !== false && process.env[SKIP_UPDATE_CHECK_ENV_VAR] !== "true" && !process.env[CUSTOM_SANDBOX_IMAGE_ENV_VAR]) {
     runDeferredTask("update_check", async () => {
       const [
         { checkForUpdatesDetailed },
         { handleAutoUpdate },
+        { getInstallationInfo },
         { updateEventEmitter },
         { t }
       ] = await Promise.all([
-        import("./updateCheck-QTVVISH7.js"),
-        import("./handleAutoUpdate-ULHNWL6R.js"),
+        import("./updateCheck-TGO2X735.js"),
+        import("./handleAutoUpdate-NGE5AQ2N.js"),
+        import("./installationInfo-4R75MFTB.js"),
         import("./updateEventEmitter-5MKC7BLQ.js"),
-        import("./i18n-CYDUTF6F.js")
+        import("./i18n-QNVR36NB.js")
       ]);
       const updateFailedMessage = t(
         "Failed to check for updates. Please check your network or registry configuration."
@@ -237,7 +245,46 @@ function startPostRenderPrefetches(config, settings, options = {}) {
       try {
         const result = await checkForUpdatesDetailed();
         if (result.status === "update") {
-          handleAutoUpdate(result.info, settings, config.getProjectRoot());
+          const projectRoot = config.getProjectRoot();
+          const hostUpdateRelaunch = process.env[HOST_UPDATE_RELAUNCH_ENV_VAR];
+          if (hostUpdateRelaunch === "true") {
+            updateEventEmitter.emit("update-info", {
+              message: `${result.info.message}
+${t(
+                "Run /update to install the update on the host."
+              )}`
+            });
+            return;
+          }
+          if (hostUpdateRelaunch === "false") {
+            updateEventEmitter.emit("update-info", {
+              message: `${result.info.message}
+${t(
+                "Update Qwen Code on the host, then restart the sandbox."
+              )}`
+            });
+            return;
+          }
+          const installationInfo = getInstallationInfo(projectRoot, true);
+          if (installationInfo.updateCommand || installationInfo.isStandalone && installationInfo.standaloneDir) {
+            if (requestUpdateOnExit()) {
+              updateEventEmitter.emit("update-info", {
+                message: `${result.info.message}
+${t(
+                  "The update will be installed after you exit this session."
+                )}`
+              });
+            } else {
+              updateEventEmitter.emit("update-info", {
+                message: `${result.info.message}
+${t(
+                  "Run /update to install the update."
+                )}`
+              });
+            }
+          } else {
+            void handleAutoUpdate(result.info, settings, projectRoot);
+          }
         } else if (result.status === "error") {
           updateEventEmitter.emit("update-failed", {
             message: updateFailedMessage
@@ -257,7 +304,7 @@ function startPostRenderPrefetches(config, settings, options = {}) {
         state: "connecting"
       });
       try {
-        const { connectIdeForStartup } = await import("./initializer-NRFKUGIO.js");
+        const { connectIdeForStartup } = await import("./initializer-ZY7ORPMH.js");
         await withTimeout(
           connectIdeForStartup(config),
           "ide_connect",
@@ -283,7 +330,7 @@ function startPostRenderPrefetches(config, settings, options = {}) {
   }
   if (config.isInteractive()) {
     runDeferredTask("background_housekeeping", async () => {
-      const { startBackgroundHousekeeping } = await import("./scheduler-JJDZBDRN.js");
+      const { startBackgroundHousekeeping } = await import("./scheduler-WTK7ZLV5.js");
       startBackgroundHousekeeping(config, settings);
     });
   }

package/chunks/{chunk-LNUXFLLJ.js → chunk-BDHYJ2MM.js}

@@ -8,7 +8,7 @@ import {
 } from "./chunk-QHTIBUWB.js";
 import {
   t
-} from "./chunk-RDRVMDWV.js";
+} from "./chunk-EMJJBXS7.js";
 import {
   require_clean,
   require_constants,
@@ -27,7 +27,7 @@ import {
   ansi_regex_exports,
   init_ansi_regex,
   stripAnsi
-} from "./chunk-K7CRWKOE.js";
+} from "./chunk-T4TZQJ7W.js";
 import {
   require_graceful_fs
 } from "./chunk-E2UVIFI2.js";
@@ -8117,6 +8117,35 @@ __name(updateNotifier, "updateNotifier");
 var import_semver2 = __toESM(require_semver2(), 1);
 var debugLogger = createDebugLogger("UPDATE_CHECK");
 var FETCH_TIMEOUT_MS = 2e3;
+var UpdateCheckTimeoutError = class extends Error {
+  static {
+    __name(this, "UpdateCheckTimeoutError");
+  }
+  distTag;
+  constructor(timeoutMs, distTag) {
+    const suffix = distTag ? ` for ${distTag}` : "";
+    super(`update-notifier fetchInfo timed out after ${timeoutMs}ms${suffix}`);
+    this.name = "UpdateCheckTimeoutError";
+    this.distTag = distTag;
+  }
+};
+async function fetchInfoWithTimeout(notifier, timeoutMs, distTag) {
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve(notifier.fetchInfo()),
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(new UpdateCheckTimeoutError(timeoutMs, distTag)),
+          timeoutMs
+        );
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+__name(fetchInfoWithTimeout, "fetchInfoWithTimeout");
 function getBestAvailableUpdate(nightly, stable) {
   if (!nightly) return stable || null;
   if (!stable) return nightly || null;
@@ -8152,9 +8181,20 @@ async function checkForUpdatesDetailed() {
     }), "createNotifier");
     if (isNightly) {
       const [nightlyUpdateInfo, latestUpdateInfo] = await Promise.all([
-        createNotifier("nightly").fetchInfo(),
-        createNotifier("latest").fetchInfo()
+        fetchInfoWithTimeout(
+          createNotifier("nightly"),
+          FETCH_TIMEOUT_MS,
+          "nightly"
+        ),
+        fetchInfoWithTimeout(
+          createNotifier("latest"),
+          FETCH_TIMEOUT_MS,
+          "latest"
+        )
       ]);
+      debugLogger.debug(
+        `fetchInfo returned nightly=${JSON.stringify(nightlyUpdateInfo)} latest=${JSON.stringify(latestUpdateInfo)} for current=${version}`
+      );
       const bestUpdate = getBestAvailableUpdate(
         nightlyUpdateInfo,
         latestUpdateInfo
@@ -8172,7 +8212,14 @@ async function checkForUpdatesDetailed() {
         };
       }
     } else {
-      const updateInfo = await createNotifier("latest").fetchInfo();
+      const updateInfo = await fetchInfoWithTimeout(
+        createNotifier("latest"),
+        FETCH_TIMEOUT_MS,
+        "latest"
+      );
+      debugLogger.debug(
+        `fetchInfo returned ${JSON.stringify(updateInfo)} for current=${version}`
+      );
       if (updateInfo && import_semver2.default.gt(updateInfo.latest, version)) {
         return {
           status: "update",
@@ -8202,6 +8249,7 @@ __name(checkForUpdates, "checkForUpdates");
 
 export {
   FETCH_TIMEOUT_MS,
+  UpdateCheckTimeoutError,
   checkForUpdatesDetailed,
   checkForUpdates
 };