@qwen-code/qwen-code 0.23.5-preview.0 → 0.24.0-nightly.20260917.f822124af5

package/chunks/{chunk-SYMXYRM5.js → chunk-W7JWIIRC.js}

@@ -3,7 +3,7 @@
 import {
   getPlugin,
   supportedTypes
-} from "./chunk-U4AASWUQ.js";
+} from "./chunk-L4GF4IK2.js";
 import {
   resolveChannelCwd
 } from "./chunk-LFKXIOGC.js";

package/chunks/{chunk-WBSJ6VPZ.js → chunk-WDVSRQIQ.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   escapeXml
-} from "./chunk-G6UUOCUT.js";
+} from "./chunk-GXNXX7A2.js";
 import {
   ToolNames
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-ERIBG3BX.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-AZCTY64Z.js → chunk-WEUQIY3Q.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   t
-} from "./chunk-GSAOVDTH.js";
+} from "./chunk-POMFSBEC.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-FX6PZBOV.js → chunk-WHBL5HJF.js}

@@ -2,19 +2,19 @@
 "use strict";
 import {
   GIT_COMMIT_INFO
-} from "./chunk-3LLEB5CU.js";
+} from "./chunk-QG73VXTF.js";
 import {
   getCliVersion
-} from "./chunk-AQP3H22J.js";
+} from "./chunk-3ZGIRRAE.js";
 import {
   IdeClient
-} from "./chunk-KAYC5FBN.js";
+} from "./chunk-Z3DLUFMT.js";
 import {
   formatMemoryUsage
 } from "./chunk-CHEIIBT3.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-WL2V7PTE.js

@@ -0,0 +1,78 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  appendOmniUsageLog,
+  parseSseCompletion
+} from "./chunk-IVPSLX4P.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/omni/policy/tools/omni-chat-request.ts
+init_esbuild_shims();
+function serializeMediaPart(part) {
+  switch (part.type) {
+    case "image_url":
+      return { type: "image_url", image_url: { url: part.url } };
+    case "video_url":
+      return { type: "video_url", video_url: { url: part.url } };
+    case "input_audio":
+      return {
+        type: "input_audio",
+        input_audio: { data: part.data, format: part.format }
+      };
+    default: {
+      const exhaustive = part;
+      throw new Error(`unknown media part type ${String(exhaustive)}`);
+    }
+  }
+}
+__name(serializeMediaPart, "serializeMediaPart");
+async function requestOmniChatCompletion(options) {
+  const requestSignal = AbortSignal.any([
+    options.signal,
+    AbortSignal.timeout(options.timeoutMs)
+  ]);
+  const content = [
+    ...options.media.map(serializeMediaPart),
+    { type: "text", text: options.prompt }
+  ];
+  const response = await fetch(
+    `${options.baseUrl.replace(/\/+$/, "")}/chat/completions`,
+    {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer ${options.apiKey}`,
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({
+        model: options.model,
+        modalities: ["text"],
+        stream: true,
+        stream_options: { include_usage: true },
+        messages: [{ role: "user", content }],
+        ...options.maxTokens !== void 0 ? { max_tokens: options.maxTokens } : {}
+      }),
+      signal: requestSignal
+    }
+  );
+  if (!response.ok) {
+    return { ok: false, error: `HTTP ${response.status}` };
+  }
+  const { text, usage } = parseSseCompletion(await response.text());
+  appendOmniUsageLog(options.model, usage, options.tool);
+  return { ok: true, text: text.trim() };
+}
+__name(requestOmniChatCompletion, "requestOmniChatCompletion");
+
+export {
+  requestOmniChatCompletion
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-OSG23MR3.js → chunk-X3T5IOX6.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   wrapForMultiplexer
-} from "./chunk-DC4ZNGH4.js";
+} from "./chunk-6DB6UHY3.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-OZEV3R3S.js → chunk-XYAB5R6E.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   theme
-} from "./chunk-4LIPOIXS.js";
+} from "./chunk-3NHJLWOD.js";
 import {
   require_jsx_runtime
 } from "./chunk-SV5PQVQE.js";
 import {
   Box_default,
   Text
-} from "./chunk-NCPFOLM2.js";
+} from "./chunk-ZTBP4SFC.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
@@ -21,7 +21,7 @@ import {
 } from "./chunk-2MIN6GRR.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-XZA32HII.js

@@ -0,0 +1,19 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+
+// packages/core/src/utils/default-qwen-model.ts
+init_esbuild_shims();
+var DEFAULT_QWEN_MODEL = "coder-model";
+
+export {
+  DEFAULT_QWEN_MODEL
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-4FLUQWJ4.js → chunk-Y3Q5OK4D.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-CQ35AJ4Z.js";
 import {
   AuthType
-} from "./chunk-7O5PYQ3M.js";
+} from "./chunk-SBP43AO6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/chunk-YDERQ7ZV.js

@@ -0,0 +1,248 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  isPlainRecord
+} from "./chunk-BQMSZSG6.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/services/media-memory/config.ts
+init_esbuild_shims();
+var OmniMemoryConfigError = class extends Error {
+  static {
+    __name(this, "OmniMemoryConfigError");
+  }
+  constructor(message) {
+    super(message);
+    this.name = "OmniMemoryConfigError";
+  }
+};
+var OMNI_MEMORY_RECALL_KINDS = [
+  "metadata",
+  "derived_media",
+  "policy_result",
+  "execution"
+];
+var DEFAULT_OMNI_MEMORY_CONFIG = {
+  collection: { maxInlineTextBytes: 65536 },
+  recall: {
+    mode: "active",
+    maxEntries: 12,
+    maxTextChars: 24e3,
+    kinds: [...OMNI_MEMORY_RECALL_KINDS],
+    includeHistoricalVersions: false,
+    active: { maxFilesPerCall: 8 },
+    sideQuery: {
+      model: null,
+      timeoutMs: 3e4,
+      maxCandidateEntries: 100,
+      maxSelectedEntries: 12,
+      maxAttempts: 1
+    }
+  }
+};
+var ROOT_KEYS = /* @__PURE__ */ new Set(["collection", "recall"]);
+var COLLECTION_KEYS = /* @__PURE__ */ new Set(["maxInlineTextBytes"]);
+var RECALL_KEYS = /* @__PURE__ */ new Set([
+  "mode",
+  "maxEntries",
+  "maxTextChars",
+  "kinds",
+  "includeHistoricalVersions",
+  "active",
+  "sideQuery"
+]);
+var ACTIVE_KEYS = /* @__PURE__ */ new Set(["maxFilesPerCall"]);
+var SIDE_QUERY_KEYS = /* @__PURE__ */ new Set([
+  "model",
+  "timeoutMs",
+  "maxCandidateEntries",
+  "maxSelectedEntries",
+  "maxAttempts"
+]);
+function fail(message) {
+  throw new OmniMemoryConfigError(message);
+}
+__name(fail, "fail");
+function requireRecord(value, where, allowedKeys) {
+  if (!isPlainRecord(value)) {
+    fail(`${where}: must be an object (got ${JSON.stringify(value)})`);
+  }
+  for (const key of Object.keys(value)) {
+    if (!allowedKeys.has(key)) {
+      fail(
+        `${where}: unknown key "${key}" (allowed: ${[...allowedKeys].join(", ")})`
+      );
+    }
+  }
+  return value;
+}
+__name(requireRecord, "requireRecord");
+function positiveInteger(value, where) {
+  if (typeof value !== "number" || !Number.isInteger(value) || value <= 0) {
+    fail(`${where}: must be a positive integer (got ${JSON.stringify(value)})`);
+  }
+  return value;
+}
+__name(positiveInteger, "positiveInteger");
+function requireBoolean(value, where) {
+  if (typeof value !== "boolean") {
+    fail(`${where}: must be a boolean (got ${JSON.stringify(value)})`);
+  }
+  return value;
+}
+__name(requireBoolean, "requireBoolean");
+function normalizeKinds(value, where) {
+  if (!Array.isArray(value) || value.length === 0) {
+    fail(`${where}: must be a non-empty array of entry kinds`);
+  }
+  const known = new Set(OMNI_MEMORY_RECALL_KINDS);
+  const seen = /* @__PURE__ */ new Set();
+  for (const kind of value) {
+    if (typeof kind !== "string" || !known.has(kind)) {
+      fail(
+        `${where}: unknown entry kind ${JSON.stringify(kind)} (allowed: ${OMNI_MEMORY_RECALL_KINDS.join(", ")})`
+      );
+    }
+    if (seen.has(kind)) {
+      fail(`${where}: duplicate entry kind "${kind}"`);
+    }
+    seen.add(kind);
+  }
+  return [...seen];
+}
+__name(normalizeKinds, "normalizeKinds");
+function normalizeOmniMemoryConfig(raw) {
+  const defaults = DEFAULT_OMNI_MEMORY_CONFIG;
+  if (raw !== void 0) {
+    requireRecord(raw, "omni.memory", ROOT_KEYS);
+  }
+  let maxInlineTextBytes = defaults.collection.maxInlineTextBytes;
+  if (raw?.collection !== void 0) {
+    const collection = requireRecord(
+      raw.collection,
+      "omni.memory.collection",
+      COLLECTION_KEYS
+    );
+    if (collection["maxInlineTextBytes"] !== void 0) {
+      maxInlineTextBytes = positiveInteger(
+        collection["maxInlineTextBytes"],
+        "omni.memory.collection.maxInlineTextBytes"
+      );
+    }
+  }
+  const recall = { ...defaults.recall };
+  recall.kinds = [...defaults.recall.kinds];
+  recall.active = { ...defaults.recall.active };
+  recall.sideQuery = { ...defaults.recall.sideQuery };
+  if (raw?.recall !== void 0) {
+    const rawRecall = requireRecord(
+      raw.recall,
+      "omni.memory.recall",
+      RECALL_KEYS
+    );
+    if (rawRecall["mode"] !== void 0) {
+      const mode = rawRecall["mode"];
+      if (mode !== "active" && mode !== "sideQuery") {
+        fail(
+          `omni.memory.recall.mode: must be "active" or "sideQuery" (got ${JSON.stringify(mode)})`
+        );
+      }
+      recall.mode = mode;
+    }
+    if (rawRecall["maxEntries"] !== void 0) {
+      recall.maxEntries = positiveInteger(
+        rawRecall["maxEntries"],
+        "omni.memory.recall.maxEntries"
+      );
+    }
+    if (rawRecall["maxTextChars"] !== void 0) {
+      recall.maxTextChars = positiveInteger(
+        rawRecall["maxTextChars"],
+        "omni.memory.recall.maxTextChars"
+      );
+    }
+    if (rawRecall["kinds"] !== void 0) {
+      recall.kinds = normalizeKinds(
+        rawRecall["kinds"],
+        "omni.memory.recall.kinds"
+      );
+    }
+    if (rawRecall["includeHistoricalVersions"] !== void 0) {
+      recall.includeHistoricalVersions = requireBoolean(
+        rawRecall["includeHistoricalVersions"],
+        "omni.memory.recall.includeHistoricalVersions"
+      );
+    }
+    if (rawRecall["active"] !== void 0) {
+      const active = requireRecord(
+        rawRecall["active"],
+        "omni.memory.recall.active",
+        ACTIVE_KEYS
+      );
+      if (active["maxFilesPerCall"] !== void 0) {
+        recall.active.maxFilesPerCall = positiveInteger(
+          active["maxFilesPerCall"],
+          "omni.memory.recall.active.maxFilesPerCall"
+        );
+      }
+    }
+    if (rawRecall["sideQuery"] !== void 0) {
+      const sq = requireRecord(
+        rawRecall["sideQuery"],
+        "omni.memory.recall.sideQuery",
+        SIDE_QUERY_KEYS
+      );
+      if (sq["model"] !== void 0) {
+        const model = sq["model"];
+        if (model !== null && (typeof model !== "string" || model === "")) {
+          fail(
+            `omni.memory.recall.sideQuery.model: must be null or a non-empty string (got ${JSON.stringify(model)})`
+          );
+        }
+        recall.sideQuery.model = model;
+      }
+      for (const key of [
+        "timeoutMs",
+        "maxCandidateEntries",
+        "maxSelectedEntries",
+        "maxAttempts"
+      ]) {
+        if (sq[key] !== void 0) {
+          recall.sideQuery[key] = positiveInteger(
+            sq[key],
+            `omni.memory.recall.sideQuery.${key}`
+          );
+        }
+      }
+    }
+  }
+  if (recall.sideQuery.maxSelectedEntries > recall.maxEntries) {
+    fail(
+      `omni.memory.recall.sideQuery.maxSelectedEntries (${recall.sideQuery.maxSelectedEntries}) must not exceed omni.memory.recall.maxEntries (${recall.maxEntries})`
+    );
+  }
+  if (recall.maxEntries > recall.sideQuery.maxCandidateEntries) {
+    fail(
+      `omni.memory.recall.maxEntries (${recall.maxEntries}) must not exceed omni.memory.recall.sideQuery.maxCandidateEntries (${recall.sideQuery.maxCandidateEntries})`
+    );
+  }
+  return { collection: { maxInlineTextBytes }, recall };
+}
+__name(normalizeOmniMemoryConfig, "normalizeOmniMemoryConfig");
+
+export {
+  OmniMemoryConfigError,
+  OMNI_MEMORY_RECALL_KINDS,
+  DEFAULT_OMNI_MEMORY_CONFIG,
+  normalizeOmniMemoryConfig
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-QGEISOJ2.js → chunk-YKM7SY3N.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   SCHEDULED_TASK_RUN_SOURCE_ID_PREFIX
-} from "./chunk-L2A5VBDL.js";
+} from "./chunk-67ZCKSV6.js";
 import {
   ChannelDeliveryError,
   MAX_CHANNEL_DELIVERY_TEXT_LENGTH
@@ -10,10 +10,10 @@ import {
 import {
   MAX_CHANNEL_DELIVERY_NAME_LENGTH,
   MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH
-} from "./chunk-3LMDSCLU.js";
+} from "./chunk-C4FISGDN.js";
 import {
   stripTerminalControlSequences
-} from "./chunk-P42KMMU6.js";
+} from "./chunk-RZZLNI74.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-HXUI5D4H.js → chunk-YRNAZIDX.js}

@@ -6,7 +6,7 @@ import {
   MAX_STREAM_GUARD_TIMEOUT_MS,
   QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,
   QWEN_STREAM_MAX_LIFETIME_MS_ENV
-} from "./chunk-KEM7MWS7.js";
+} from "./chunk-KWZ2DDOC.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-MFDKHGTD.js → chunk-YRNLF4SV.js}

@@ -12,12 +12,13 @@ import {
 import {
   DEFAULT_EXCLUDED_ENV_VARS,
   HOME_ENV_BOOTSTRAP_KEYS,
+  captureEnvironmentBeforeLoad,
   isHardcodedProjectEnvExclusion,
   isLoaderEnvKey,
   isPrivateProvenanceEnvKey,
   publishPendingCompileCache,
   reportRejectedLoaderKeys
-} from "./chunk-6OTF7TTE.js";
+} from "./chunk-4VYTH6OF.js";
 import {
   buildTrustPrecedenceRules,
   require_strip_json_comments,
@@ -213,6 +214,7 @@ function setUpCloudShellEnvironmentFromFilesFastPath(envFilePaths) {
 __name(setUpCloudShellEnvironmentFromFilesFastPath, "setUpCloudShellEnvironmentFromFilesFastPath");
 var serveFastPathRejectedLoaderKeys = [];
 function loadServeFastPathEnvironment(settings, startDir = process.cwd()) {
+  captureEnvironmentBeforeLoad();
   const userLevelPaths = getUserLevelEnvPathsFastPath();
   const envFilePaths = findEnvFilesFastPath(settings, startDir, userLevelPaths);
   const rejectedLoaderKeys = [];

package/chunks/{chunk-3XBUCOWS.js → chunk-YSD6IY6F.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   ResponsesHttpError
-} from "./chunk-M4U2LTD2.js";
+} from "./chunk-MS4SXNJ6.js";
 import {
   getErrorStatus,
   isAbortError
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-S34QJ6IR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-CH2YDT6X.js → chunk-YVYK3JYU.js}

@@ -2,11 +2,13 @@
 "use strict";
 import {
   atomicWriteJSON
-} from "./chunk-XFFRI3WM.js";
+} from "./chunk-CA63HYHU.js";
+import {
+  Storage
+} from "./chunk-ZYDMQCQP.js";
 import {
-  Storage,
   isNodeError
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-S34QJ6IR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-YL3UJML3.js → chunk-YWDVNBGE.js}

@@ -8,16 +8,16 @@ import {
 } from "./chunk-YXHY6BKS.js";
 import {
   ChannelWorkerStartupError
-} from "./chunk-XAJZFGD2.js";
+} from "./chunk-PXXYQOZO.js";
 import {
   ChannelWebhookEnqueueError
 } from "./chunk-STUJ7IMZ.js";
-import {
-  MAX_CHANNEL_CONTROL_WORKSPACES
-} from "./chunk-CJ3DHN5I.js";
 import {
   ChannelDeliveryError
 } from "./chunk-RKFGE7JH.js";
+import {
+  MAX_CHANNEL_CONTROL_WORKSPACES
+} from "./chunk-CJ3DHN5I.js";
 import {
   CHANNEL_LOOP_MCP_SERVER_NAME
 } from "./chunk-PZRXWQUA.js";