@qwen-code/qwen-code 0.23.5-preview.0 → 0.24.0

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-AKRSSKUT.js → chunk-YFHX6MOF.js}

@@ -2,36 +2,36 @@
 "use strict";
 import {
   mapSkillConfigToStatus
-} from "./chunk-TKF4JINY.js";
-import {
-  resolveSkillSettings
-} from "./chunk-D7JMO2GP.js";
+} from "./chunk-3FEGERVL.js";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-M23GFJ5B.js";
+} from "./chunk-EHMLJKF5.js";
+import {
+  resolveSkillSettings
+} from "./chunk-DNHL4S5B.js";
 import {
   loadSettings
-} from "./chunk-RRI764F7.js";
+} from "./chunk-VPFKSRAB.js";
 import {
   resolveLanguage,
   resolveLanguageSetting
-} from "./chunk-GSAOVDTH.js";
+} from "./chunk-POMFSBEC.js";
 import {
   ExtensionManager,
   ExtensionStore,
   SkillManager,
   getExtensionDisplayName
-} from "./chunk-KAYC5FBN.js";
+} from "./chunk-SNPYTKXI.js";
 import {
   authoredSkillName,
   qualifySkillName
-} from "./chunk-P42KMMU6.js";
+} from "./chunk-KWTLCPYY.js";
 import {
   isSafeModeEnv
 } from "./chunk-ADN5KESB.js";
 import {
   Storage
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   writeStderrLine
 } from "./chunk-7FA2II6K.js";

package/chunks/{chunk-ZMYKNKET.js → chunk-YPJZDZMP.js}

@@ -27,10 +27,10 @@ import {
 } from "./chunk-3VUENPWF.js";
 import {
   loadSettings
-} from "./chunk-RRI764F7.js";
+} from "./chunk-VPFKSRAB.js";
 import {
   MCP_BUDGET_WARN_FRACTION
-} from "./chunk-KAYC5FBN.js";
+} from "./chunk-SNPYTKXI.js";
 import {
   parsePositiveIntegerEnv
 } from "./chunk-6PVPNMXU.js";
@@ -447,7 +447,7 @@ var serveCommand = {
     delete process.env[EXTERNAL_TOOL_GUARD_TOKEN_ENV];
     const openWithAuth = argv["open-with-auth"];
     const open = argv.open || openWithAuth;
-    const { runQwenServe } = await import("./run-qwen-serve-ZVEKGS7Y.js");
+    const { runQwenServe } = await import("./run-qwen-serve-3K3D5MSR.js");
     try {
       const serveOptions = {
         port: argv.port,

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";

package/chunks/{chunk-C3T6HPNM.js → chunk-ZGADNVME.js}

@@ -1,20 +1,20 @@
 // Force strict mode and setup for ESM
 "use strict";
-import {
-  t
-} from "./chunk-GSAOVDTH.js";
 import {
   require_semver
 } from "./chunk-2AUM35J5.js";
 import {
   getNpmCliPath
-} from "./chunk-SFL6U7U7.js";
+} from "./chunk-4JFRCIMW.js";
+import {
+  t
+} from "./chunk-POMFSBEC.js";
 import {
   getPackageJson
 } from "./chunk-W3N5XAZ6.js";
 import {
   createDebugLogger
-} from "./chunk-ZAFYHRVY.js";
+} from "./chunk-ZYDMQCQP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-M3JGHRMQ.js → chunk-ZJ7KIWG5.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   atomicWriteFileSync
-} from "./chunk-XFFRI3WM.js";
+} from "./chunk-CA63HYHU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QHSOINX6.js → chunk-ZJBYZN5D.js}

@@ -2,10 +2,10 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-HYHSMTRA.js";
+} from "./chunk-6XRR4RYH.js";
 import {
   observeHeadlessJsonToolResultWire
-} from "./chunk-HNFKYKHH.js";
+} from "./chunk-SMAAYU3F.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-SYROIHU7.js → chunk-ZRQGTRHA.js}

@@ -2,10 +2,12 @@
 "use strict";
 import {
   BaseDeclarativeTool,
-  BaseToolInvocation,
+  BaseToolInvocation
+} from "./chunk-VPGRGNNH.js";
+import {
   ToolDisplayNames,
   ToolNames
-} from "./chunk-RSWBT7AZ.js";
+} from "./chunk-ERIBG3BX.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-NCPFOLM2.js → chunk-ZTBP4SFC.js}

@@ -19571,6 +19571,44 @@ var emptyMetrics = {
   left: 0,
   top: 0
 };
+var maxSelfDrivenMeasurements = 16;
+var measurementGuards = /* @__PURE__ */ new WeakMap();
+var getMeasurementGuard = /* @__PURE__ */ __name((rootNode) => {
+  const existing = measurementGuards.get(rootNode);
+  if (existing) {
+    return existing;
+  }
+  const guard = {
+    count: 0,
+    listeners: /* @__PURE__ */ new Set()
+  };
+  measurementGuards.set(rootNode, guard);
+  addLayoutListener(rootNode, () => {
+    if (guard.count >= maxSelfDrivenMeasurements) {
+      return;
+    }
+    let changed = false;
+    for (const listener of guard.listeners) {
+      changed = listener() || changed;
+    }
+    if (changed) {
+      if (guard.count === 0) {
+        queueMicrotask(() => {
+          guard.count = 0;
+        });
+      }
+      guard.count += 1;
+    }
+  });
+  return guard;
+}, "getMeasurementGuard");
+var addMeasurementListener = /* @__PURE__ */ __name((rootNode, listener) => {
+  const guard = getMeasurementGuard(rootNode);
+  guard.listeners.add(listener);
+  return () => {
+    guard.listeners.delete(listener);
+  };
+}, "addMeasurementListener");
 var findRootNode = /* @__PURE__ */ __name((node) => {
   if (!node) {
     return void 0;
@@ -19583,38 +19621,60 @@ var findRootNode = /* @__PURE__ */ __name((node) => {
 var useBoxMetrics = /* @__PURE__ */ __name((ref) => {
   const [metrics, setMetrics] = (0, import_react33.useState)(emptyMetrics);
   const [hasMeasured, setHasMeasured] = (0, import_react33.useState)(false);
-  const guardRef = (0, import_react33.useRef)({ count: 0, windowStart: 0 });
+  const stateRef = (0, import_react33.useRef)({
+    last: null,
+    hasMeasured: false,
+    rootNode: void 0
+  });
   const { stdout } = use_stdout_default();
   const updateMetrics = (0, import_react33.useCallback)(() => {
-    const guard = guardRef.current;
-    const now = performance.now();
-    if (now - guard.windowStart >= 16) {
-      guard.count = 0;
-      guard.windowStart = now;
+    const state = stateRef.current;
+    const rootNode = findRootNode(ref.current) ?? state.rootNode;
+    if (rootNode) {
+      state.rootNode = rootNode;
     }
-    if (guard.count >= 32) {
-      return;
+    const guard = rootNode ? getMeasurementGuard(rootNode) : void 0;
+    if (guard?.count >= maxSelfDrivenMeasurements) {
+      return false;
     }
-    guard.count += 1;
     const layout = ref.current?.yogaNode?.getComputedLayout() ?? emptyMetrics;
-    setMetrics((previousMetrics) => {
-      const hasChanged = previousMetrics.width !== layout.width || previousMetrics.height !== layout.height || previousMetrics.left !== layout.left || previousMetrics.top !== layout.top;
-      return hasChanged ? layout : previousMetrics;
-    });
-    setHasMeasured(Boolean(ref.current));
+    const last = state.last;
+    const hasChanged = last === null || last.width !== layout.width || last.height !== layout.height || last.left !== layout.left || last.top !== layout.top;
+    if (hasChanged) {
+      state.last = layout;
+      setMetrics(layout);
+    }
+    const nextHasMeasured = Boolean(ref.current);
+    const hasMeasuredChanged = nextHasMeasured !== state.hasMeasured;
+    if (hasMeasuredChanged) {
+      state.hasMeasured = nextHasMeasured;
+    }
+    setHasMeasured(nextHasMeasured);
+    return hasChanged || hasMeasuredChanged;
   }, [ref]);
-  (0, import_react33.useEffect)(updateMetrics);
+  (0, import_react33.useEffect)(() => {
+    updateMetrics();
+  });
   (0, import_react33.useEffect)(() => {
     const rootNode = findRootNode(ref.current);
     if (!rootNode) {
       return;
     }
-    return addLayoutListener(rootNode, updateMetrics);
+    stateRef.current.rootNode = rootNode;
+    return addMeasurementListener(rootNode, updateMetrics);
   });
   (0, import_react33.useEffect)(() => {
-    stdout.on("resize", updateMetrics);
+    const onResize = /* @__PURE__ */ __name(() => {
+      const rootNode = findRootNode(ref.current) ?? stateRef.current.rootNode;
+      if (rootNode) {
+        const guard = getMeasurementGuard(rootNode);
+        guard.count = 0;
+      }
+      updateMetrics();
+    }, "onResize");
+    stdout.on("resize", onResize);
     return () => {
-      stdout.off("resize", updateMetrics);
+      stdout.off("resize", onResize);
     };
   }, [stdout, updateMetrics]);
   return (0, import_react33.useMemo)(() => ({