@zubriq/code 0.19.8-2 → 0.19.9-2

package/dist/chunks/chunk-A7JD2K4Z.js

@@ -0,0 +1,28 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getPackageJson
+} from "./chunk-43W4YSO6.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/utils/version.ts
+init_esbuild_shims();
+async function getCliVersion() {
+  const pkgJson = await getPackageJson();
+  return "0.19.9-2";
+}
+__name(getCliVersion, "getCliVersion");
+
+export {
+  getCliVersion
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunks/{chunk-3CRBBLJZ.js → chunk-BAC5H5F4.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   handleAtCommand
-} from "./chunk-AGTU5PQ6.js";
+} from "./chunk-UWRIDCTO.js";
 import {
   JsonOutputAdapter
-} from "./chunk-PYWGOON5.js";
+} from "./chunk-XPS3UH2D.js";
 import {
   StreamJsonOutputAdapter
-} from "./chunk-QUR23Z2Q.js";
+} from "./chunk-M6F3JCGI.js";
 import {
   buildInitialSystemReminders,
   buildSystemMessage,
@@ -20,10 +20,10 @@ import {
   insertAfterFunctionResponses,
   isSlashCommand,
   normalizePartList
-} from "./chunk-OMO3UY57.js";
+} from "./chunk-VFGM47DK.js";
 import {
   RunBudgetEnforcer
-} from "./chunk-VQZSRYKB.js";
+} from "./chunk-OFGYDQPN.js";
 import {
   AlreadyReportedError,
   handleBudgetExceededError,
@@ -31,10 +31,10 @@ import {
   handleError,
   handleMaxTurnsExceededError,
   handleToolError
-} from "./chunk-23TH7TAA.js";
+} from "./chunk-UNP2RK7B.js";
 import {
   isInlineModelOverrideAllowed
-} from "./chunk-VEDR5V7H.js";
+} from "./chunk-ITIH3WEE.js";
 import {
   ORPHAN_TOOL_USE_REPAIR_REASON,
   buildSyntheticToolResponseParts,
@@ -49,12 +49,12 @@ import {
   parseAndFormatApiError,
   promptIdContext,
   restoreWorktreeContext
-} from "./chunk-FACTYQFS.js";
+} from "./chunk-72AW57IS.js";
 import {
   isTelemetrySdkInitialized,
   shutdownTelemetry,
   uiTelemetryService
-} from "./chunk-O3DVJ2JO.js";
+} from "./chunk-2DFYBHN4.js";
 import {
   ToolNames
 } from "./chunk-X3YGAX7V.js";

package/dist/chunks/{chunk-46IFEQDM.js → chunk-BIO6D3EL.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   parseRule
-} from "./chunk-FACTYQFS.js";
+} from "./chunk-72AW57IS.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/dist/chunks/chunk-BLNH4ALH.js

@@ -0,0 +1,283 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  appEvents
+} from "./chunk-OFGYDQPN.js";
+import {
+  require_undici
+} from "./chunk-54YZOP7P.js";
+import {
+  IdeClient,
+  getAllProviderBaseUrls
+} from "./chunk-72AW57IS.js";
+import {
+  initializeTelemetry
+} from "./chunk-2DFYBHN4.js";
+import {
+  detectRuntime,
+  getOrCreateSharedDispatcher,
+  redactProxyCredentials
+} from "./chunk-H6EMK6QK.js";
+import {
+  createDebugLogger
+} from "./chunk-22MNNNXE.js";
+import {
+  recordStartupEvent
+} from "./chunk-ITOGNELQ.js";
+import {
+  init_esbuild_shims
+} from "./chunk-A4BMJM77.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/startup/startup-prefetch.ts
+init_esbuild_shims();
+
+// packages/cli/src/utils/apiPreconnect.ts
+init_esbuild_shims();
+var import_undici = __toESM(require_undici(), 1);
+var debugLogger = createDebugLogger("PRECONNECT");
+var preconnectFired = false;
+var DEFAULT_BASE_URLS = {
+  openai: "https://api.openai.com",
+  "qwen-oauth": "https://coding.dashscope.aliyuncs.com",
+  anthropic: "https://api.anthropic.com",
+  dashscope: "https://dashscope.aliyuncs.com"
+};
+var ALL_DEFAULT_URLS = [
+  ...Object.values(DEFAULT_BASE_URLS),
+  ...getAllProviderBaseUrls()
+];
+function shouldSkipPreconnect() {
+  if (process.env["NODE_EXTRA_CA_CERTS"]) {
+    debugLogger.debug("Skipping preconnect: custom CA certificate configured");
+    return true;
+  }
+  return false;
+}
+__name(shouldSkipPreconnect, "shouldSkipPreconnect");
+function isInSandboxMode() {
+  return process.env["SANDBOX"] !== void 0;
+}
+__name(isInSandboxMode, "isInSandboxMode");
+function isDefaultBaseUrl(baseUrl) {
+  const normalizedInput = baseUrl.toLowerCase().replace(/^https?:\/\//, "").replace(/\/+$/, "");
+  return ALL_DEFAULT_URLS.some((defaultUrl) => {
+    const normalizedDefault = defaultUrl.toLowerCase().replace(/^https?:\/\//, "").replace(/\/+$/, "");
+    return normalizedInput === normalizedDefault || normalizedInput.startsWith(normalizedDefault + "/");
+  });
+}
+__name(isDefaultBaseUrl, "isDefaultBaseUrl");
+function getPreconnectTargetUrl(authType, resolvedBaseUrl) {
+  if (resolvedBaseUrl && /^https?:\/\//i.test(resolvedBaseUrl)) {
+    if (isDefaultBaseUrl(resolvedBaseUrl)) {
+      return resolvedBaseUrl;
+    }
+    debugLogger.debug(
+      "Skipping preconnect: resolved baseUrl is not a default URL"
+    );
+    return void 0;
+  }
+  if (authType && DEFAULT_BASE_URLS[authType]) {
+    return DEFAULT_BASE_URLS[authType];
+  }
+  return void 0;
+}
+__name(getPreconnectTargetUrl, "getPreconnectTargetUrl");
+function preconnectApi(authType, options = {}) {
+  if (preconnectFired) {
+    return;
+  }
+  if (process.env["QWEN_CODE_DISABLE_PRECONNECT"] === "1") {
+    debugLogger.debug("Preconnect disabled by environment variable");
+    preconnectFired = true;
+    return;
+  }
+  if (isInSandboxMode()) {
+    debugLogger.debug("Skipping preconnect: sandbox mode detected");
+    preconnectFired = true;
+    return;
+  }
+  if (shouldSkipPreconnect()) {
+    preconnectFired = true;
+    return;
+  }
+  if (detectRuntime() !== "node") {
+    debugLogger.debug("Skipping preconnect: unsupported runtime");
+    preconnectFired = true;
+    return;
+  }
+  if (!options.proxy) {
+    debugLogger.debug("Skipping preconnect dispatcher: no proxy configured");
+    return;
+  }
+  const proxy = options.proxy;
+  const targetUrl = getPreconnectTargetUrl(authType, options.resolvedBaseUrl);
+  if (!targetUrl) {
+    debugLogger.debug("No target URL for preconnect");
+    return;
+  }
+  preconnectFired = true;
+  debugLogger.debug(`Preconnecting to: ${targetUrl}`);
+  try {
+    const dispatcher = getOrCreateSharedDispatcher(proxy);
+    (0, import_undici.fetch)(targetUrl, {
+      method: "HEAD",
+      signal: AbortSignal.timeout(5e3),
+      headers: {
+        "User-Agent": "QwenCode-Preconnect/1.0"
+      },
+      dispatcher
+    }).then(() => {
+      debugLogger.debug("Preconnect completed");
+    }).catch((error) => {
+      const redactedError = redactProxyCredentials(String(error));
+      debugLogger.debug(`Preconnect failed (ignored): ${redactedError}`);
+    });
+  } catch (error) {
+    const redactedError = redactProxyCredentials(String(error));
+    debugLogger.debug(`Preconnect failed (ignored): ${redactedError}`);
+  }
+}
+__name(preconnectApi, "preconnectApi");
+
+// packages/cli/src/startup/startup-prefetch.ts
+var debugLogger2 = createDebugLogger("STARTUP_PREFETCH");
+var DEFERRED_IDE_CONNECT_TIMEOUT_MS = 15e3;
+var earlyStarted = /* @__PURE__ */ new WeakSet();
+var postRenderStarted = /* @__PURE__ */ new WeakSet();
+function withTimeout(promise, name, timeoutMs, onTimeout = () => {
+}) {
+  let timeoutId;
+  let timedOut = false;
+  const runTimeoutCleanup = /* @__PURE__ */ __name(() => {
+    void Promise.resolve().then(onTimeout).catch((err) => {
+      debugLogger2.debug(`${name} timeout cleanup failed:`, err);
+    });
+  }, "runTimeoutCleanup");
+  const timeout = new Promise((_, reject) => {
+    timeoutId = setTimeout(() => {
+      timedOut = true;
+      runTimeoutCleanup();
+      reject(new Error(`${name} timed out after ${timeoutMs}ms`));
+    }, timeoutMs);
+    timeoutId.unref?.();
+  });
+  void promise.then(
+    () => {
+      if (timedOut) {
+        runTimeoutCleanup();
+      }
+    },
+    (err) => {
+      if (timedOut) {
+        debugLogger2.debug(`${name} underlying error after timeout:`, err);
+      }
+    }
+  );
+  return Promise.race([promise, timeout]).finally(() => {
+    if (timeoutId) {
+      clearTimeout(timeoutId);
+    }
+  });
+}
+__name(withTimeout, "withTimeout");
+function runDeferredTask(name, task) {
+  recordStartupEvent("startup_prefetch_started", { name });
+  void Promise.resolve().then(task).then(() => {
+    recordStartupEvent("startup_prefetch_completed", { name });
+  }).catch((err) => {
+    recordStartupEvent("startup_prefetch_failed", { name });
+    debugLogger2.warn(`${name} failed:`, err);
+  });
+}
+__name(runDeferredTask, "runDeferredTask");
+async function disconnectIdeAfterDeferredTimeout() {
+  const ideClient = await IdeClient.getInstance();
+  await ideClient.disconnect();
+}
+__name(disconnectIdeAfterDeferredTimeout, "disconnectIdeAfterDeferredTimeout");
+function startEarlyStartupPrefetches(config) {
+  if (earlyStarted.has(config)) return;
+  earlyStarted.add(config);
+  try {
+    const modelsConfig = config.getModelsConfig();
+    const authType = modelsConfig.getCurrentAuthType();
+    const resolvedBaseUrl = modelsConfig.getGenerationConfig().baseUrl;
+    const proxy = config.getProxy();
+    preconnectApi(authType, { resolvedBaseUrl, proxy });
+  } catch (error) {
+    debugLogger2.debug(
+      `Preconnect skipped due to error getting authType: ${error}`
+    );
+  }
+}
+__name(startEarlyStartupPrefetches, "startEarlyStartupPrefetches");
+function startPostRenderPrefetches(config, settings, options = {}) {
+  if (postRenderStarted.has(config)) return;
+  postRenderStarted.add(config);
+  if (settings.merged.general?.enableAutoUpdate !== false) {
+    runDeferredTask("update_check", async () => {
+      const [{ checkForUpdates }, { handleAutoUpdate }] = await Promise.all([
+        import("./updateCheck-BHMVBNNI.js"),
+        import("./handleAutoUpdate-K73DXUO2.js")
+      ]);
+      const info = await checkForUpdates();
+      handleAutoUpdate(info, settings, config.getProjectRoot());
+    });
+  }
+  if (options.connectIde && config.getIdeMode()) {
+    runDeferredTask("ide_connect", async () => {
+      appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
+        state: "connecting"
+      });
+      try {
+        const { connectIdeForStartup } = await import("./initializer-O2E3RKOG.js");
+        await withTimeout(
+          connectIdeForStartup(config),
+          "ide_connect",
+          DEFERRED_IDE_CONNECT_TIMEOUT_MS,
+          disconnectIdeAfterDeferredTimeout
+        );
+        appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
+          state: "connected"
+        });
+      } catch (err) {
+        appEvents.emit("startup-ide-connection-status-changed" /* StartupIdeConnectionStatusChanged */, {
+          state: "failed",
+          message: err instanceof Error ? err.message : String(err)
+        });
+        throw err;
+      }
+    });
+  }
+  if (options.initializeTelemetry) {
+    runDeferredTask("telemetry_init", () => {
+      initializeTelemetry(config);
+    });
+  }
+  if (config.isInteractive()) {
+    runDeferredTask("background_housekeeping", async () => {
+      const { startBackgroundHousekeeping } = await import("./scheduler-CTJIZOWI.js");
+      startBackgroundHousekeeping(config, settings);
+    });
+  }
+}
+__name(startPostRenderPrefetches, "startPostRenderPrefetches");
+
+export {
+  startEarlyStartupPrefetches,
+  startPostRenderPrefetches
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
+/**
+ * @license
+ * Copyright 2026 Qwen Code
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/dist/chunks/{chunk-GXQXFHYV.js → chunk-CBYHA7QC.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   registerCleanup
-} from "./chunk-ZCMLUE4O.js";
+} from "./chunk-27A4SPWJ.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/dist/chunks/{chunk-NCFY7PWS.js → chunk-CCGOFQV3.js}

@@ -10,6 +10,53 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// packages/core/src/utils/request-tokenizer/textTokenizer.ts
+init_esbuild_shims();
+function estimateTextTokens(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);
+}
+__name(estimateTextTokens, "estimateTextTokens");
+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) {
+    return estimateTextTokens(text);
+  }
+};
+
 // packages/core/src/utils/runtimeDiagnostics.ts
 init_esbuild_shims();
 var RUNTIME_PROFILE_ENV = "QWEN_CODE_PROFILE_RUNTIME";
@@ -1193,6 +1240,8 @@ function toOpenAPI30(schema) {
 __name(toOpenAPI30, "toOpenAPI30");
 
 export {
+  estimateTextTokens,
+  TextTokenizer,
   safeJsonParse,
   convertSchema,
   isRuntimeDiagnosticsEnabled,
@@ -1203,12 +1252,12 @@ export {
 };
 /**
  * @license
- * Copyright 2026 Qwen
+ * Copyright 2025 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**
  * @license
- * Copyright 2025 Qwen
+ * Copyright 2026 Qwen
  * SPDX-License-Identifier: Apache-2.0
  */
 /**

package/dist/chunks/{chunk-66KNL43D.js → chunk-CD6USWHZ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   getGlobalQwenDir
-} from "./chunk-WSVZFWN4.js";
+} from "./chunk-IBY3Q3HG.js";
 import {
   init_esbuild_shims
 } from "./chunk-A4BMJM77.js";

package/dist/chunks/{chunk-J6GMF2DO.js → chunk-CJGGW5FV.js}

@@ -5,10 +5,10 @@ import {
   TaggedThinkingParser,
   getRateLimitErrorDetails,
   openaiRequestCaptureContext
-} from "./chunk-O3DVJ2JO.js";
+} from "./chunk-2DFYBHN4.js";
 import {
   RequestTokenizer
-} from "./chunk-W6RH6KHR.js";
+} from "./chunk-3GPVYALM.js";
 import {
   DASHSCOPE_PROXY_BASE_URL,
   DEFAULT_DASHSCOPE_BASE_URL,
@@ -20,11 +20,11 @@ import {
   parsePositiveIntegerEnvValue,
   resolveRequestTimeout,
   tokenLimit
-} from "./chunk-PIORL4OD.js";
+} from "./chunk-UKV3D7WB.js";
 import {
   runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-NCFY7PWS.js";
+} from "./chunk-CCGOFQV3.js";
 import {
   GenerateContentResponse
 } from "./chunk-55ZMG67I.js";
@@ -8154,6 +8154,33 @@ var StreamInactivityTimeoutError = class extends Error {
   }
   code = "ETIMEDOUT";
 };
+var NON_SSE_BODY_PREFIX_LIMIT = 512;
+function isSSECompatibleContentType(contentType) {
+  if (!contentType) return true;
+  const mediaType = (contentType.split(";")[0] ?? "").trim().toLowerCase();
+  return mediaType === "text/event-stream" || mediaType === "application/x-ndjson" || mediaType === "application/stream+json";
+}
+__name(isSSECompatibleContentType, "isSSECompatibleContentType");
+var NonSSEResponseError = class extends Error {
+  constructor(contentType, httpStatus, bodyPrefix, requestId) {
+    const preview = bodyPrefix.length > 0 ? ` Body prefix: ${bodyPrefix}` : "";
+    super(
+      `Streaming request received a non-SSE response (HTTP ${httpStatus}, Content-Type: ${contentType || "unknown"}).${preview}`
+    );
+    this.contentType = contentType;
+    this.httpStatus = httpStatus;
+    this.bodyPrefix = bodyPrefix;
+    this.requestId = requestId;
+    this.name = "NonSSEResponseError";
+    this.status = httpStatus;
+    this.request_id = requestId;
+  }
+  static {
+    __name(this, "NonSSEResponseError");
+  }
+  status;
+  request_id;
+};
 function resolveStreamIdleTimeoutMs(config) {
   const fromConfig = config.streamIdleTimeoutMs;
   if (typeof fromConfig === "number") {
@@ -8283,9 +8310,41 @@ var ContentGenerationPipeline = class {
         const perRequestAc = createChildAbortController(parentSignal);
         let stream;
         try {
-          stream = await this.client.chat.completions.create(openaiRequest, {
-            signal: perRequestAc.signal
-          });
+          const createPromise = this.client.chat.completions.create(
+            openaiRequest,
+            { signal: perRequestAc.signal }
+          );
+          if (typeof createPromise.withResponse === "function") {
+            const {
+              data,
+              response: httpResponse,
+              request_id
+            } = await createPromise.withResponse();
+            stream = data;
+            const contentType = httpResponse.headers.get("content-type") ?? null;
+            if (!isSSECompatibleContentType(contentType)) {
+              let bodyPrefix = "";
+              try {
+                if (httpResponse.body) {
+                  const reader = httpResponse.body.getReader();
+                  const { value } = await reader.read();
+                  reader.releaseLock();
+                  if (value) {
+                    bodyPrefix = new TextDecoder().decode(value).slice(0, NON_SSE_BODY_PREFIX_LIMIT);
+                  }
+                }
+              } catch {
+              }
+              throw new NonSSEResponseError(
+                contentType,
+                httpResponse.status,
+                bodyPrefix,
+                request_id
+              );
+            }
+          } else {
+            stream = await createPromise;
+          }
         } catch (e) {
           perRequestAc.abort();
           throw e;

package/dist/chunks/{chunk-LLVYPOQV.js → chunk-COUVVSMO.js}

@@ -7,14 +7,14 @@ import {
   Box_default,
   Text,
   require_jsx_runtime
-} from "./chunk-GSNACUDM.js";
+} from "./chunk-RBXWE376.js";
 import {
   require_react
 } from "./chunk-KYMBIKIW.js";
 import {
   stringWidth,
   toCodePoints
-} from "./chunk-AKSRZ5BA.js";
+} from "./chunk-SBP3QB6S.js";
 import {
   createDebugLogger
 } from "./chunk-22MNNNXE.js";

package/dist/chunks/{chunk-A6XKBVOM.js → chunk-EHLC565U.js}

@@ -2,12 +2,12 @@
 "use strict";
 import {
   buildPermissionSettings
-} from "./chunk-46IFEQDM.js";
+} from "./chunk-BIO6D3EL.js";
 import {
   resolveVoiceStreamConfig,
   resolveVoiceTranscriptionConfig,
   transcribeVoiceAudio
-} from "./chunk-PY6PG4BL.js";
+} from "./chunk-K6VOOZB4.js";
 import {
   getVoiceSettingsScope,
   isSelectableVoiceModel,
@@ -16,15 +16,11 @@ import {
   readVoiceMode,
   readVoiceModel,
   resolveVoiceTransport
-} from "./chunk-SWHGVEH5.js";
+} from "./chunk-O2JNBKLL.js";
 import {
   WorkspacePermissionRulesSessionRequiredError,
   WorkspaceSettingsPartialPersistError
 } from "./chunk-BMFMJINR.js";
-import {
-  getPersistScopeForModelSelection,
-  loadSettings
-} from "./chunk-7SZJYZPR.js";
 import {
   MCP_RESTART_SERVER_DEADLINE_MS
 } from "./chunk-P7M4GA57.js";
@@ -36,7 +32,11 @@ import {
   WorkspaceInitPathEscapeError,
   WorkspaceInitRaceError,
   WorkspaceInitSymlinkError
-} from "./chunk-B34OV7K2.js";
+} from "./chunk-GGQQA4JW.js";
+import {
+  getPersistScopeForModelSelection,
+  loadSettings
+} from "./chunk-YWRV5OJX.js";
 import {
   SERVE_CONTROL_EXT_METHODS,
   SERVE_STATUS_EXT_METHODS,
@@ -49,16 +49,16 @@ import {
   createIdleWorkspaceProvidersStatus,
   createIdleWorkspaceSkillsStatus,
   mapDomainErrorToErrorKind
-} from "./chunk-Z33V6JSK.js";
+} from "./chunk-ZF7UGIJ2.js";
 import {
   getWorkspaceTrustStatus
-} from "./chunk-Z3VQSA4A.js";
+} from "./chunk-67JZ37FW.js";
 import {
   writeStderrLine
 } from "./chunk-Y6Z2O3WR.js";
 import {
   ModelsConfig
-} from "./chunk-FACTYQFS.js";
+} from "./chunk-72AW57IS.js";
 import {
   createDebugLogger
 } from "./chunk-22MNNNXE.js";