@qwen-code/qwen-code 0.21.0 → 0.21.1-simplify-system-prompt.0

package/chunks/chunk-TF2X2WCT.js

@@ -0,0 +1,363 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getPlugin
+} from "./chunk-MK7VQDN3.js";
+import {
+  loadSettings,
+  saveSettings
+} from "./chunk-JALU3ZDU.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/channel-settings-store.ts
+init_esbuild_shims();
+import { createHash } from "node:crypto";
+import { isDeepStrictEqual } from "node:util";
+var ChannelSettingsError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ChannelSettingsError";
+  }
+  static {
+    __name(this, "ChannelSettingsError");
+  }
+};
+function revisionOf(channels, startupNames) {
+  return createHash("sha256").update(JSON.stringify({ channels, startupNames })).digest("hex");
+}
+__name(revisionOf, "revisionOf");
+function applySecretUpdate(current, update) {
+  validateSecretUpdate(update);
+  if (update.operation === "preserve") return current;
+  if (update.operation === "clear") return void 0;
+  if (typeof update.value !== "string" || update.value.length === 0) {
+    throw invalidSecret("Secret replacements must be non-empty strings.");
+  }
+  return update.value;
+}
+__name(applySecretUpdate, "applySecretUpdate");
+function invalidSecret(message) {
+  return new ChannelSettingsError("channel_settings_invalid_secret", message);
+}
+__name(invalidSecret, "invalidSecret");
+function invalidConfig(message) {
+  return new ChannelSettingsError("channel_settings_invalid_config", message);
+}
+__name(invalidConfig, "invalidConfig");
+var UNSAFE_OBJECT_KEYS = /* @__PURE__ */ new Set(["__proto__", "constructor", "prototype"]);
+function assertSafeChannelName(name) {
+  if (UNSAFE_OBJECT_KEYS.has(name)) {
+    throw new ChannelSettingsError(
+      "channel_settings_invalid_name",
+      `Channel name ${JSON.stringify(name)} is not allowed.`
+    );
+  }
+}
+__name(assertSafeChannelName, "assertSafeChannelName");
+function assertUpsertChannelName(name) {
+  assertSafeChannelName(name);
+  if (isAllStartupName(name)) {
+    throw new ChannelSettingsError(
+      "channel_settings_invalid_name",
+      `Channel name ${JSON.stringify(name)} is reserved for startup selection.`
+    );
+  }
+}
+__name(assertUpsertChannelName, "assertUpsertChannelName");
+function isAllStartupName(name) {
+  return name.trim() === "all";
+}
+__name(isAllStartupName, "isAllStartupName");
+function isRecord(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+__name(isRecord, "isRecord");
+function isEnvironmentReference(value) {
+  return /^\$[A-Za-z_][A-Za-z0-9_]*$/.test(value);
+}
+__name(isEnvironmentReference, "isEnvironmentReference");
+function assertStringRecord(key, value, allowedKeys) {
+  if (!isRecord(value)) {
+    throw invalidConfig(`Channel field "${key}" must be an object.`);
+  }
+  for (const [nestedKey, nestedValue] of Object.entries(value)) {
+    if (!allowedKeys.has(nestedKey) || typeof nestedValue !== "string") {
+      throw invalidConfig(`Channel field "${key}.${nestedKey}" is invalid.`);
+    }
+  }
+}
+__name(assertStringRecord, "assertStringRecord");
+function assertNumberRecord(key, value, allowedKeys) {
+  if (!isRecord(value)) {
+    throw invalidConfig(`Channel field "${key}" must be an object.`);
+  }
+  for (const [nestedKey, nestedValue] of Object.entries(value)) {
+    if (!allowedKeys.has(nestedKey) || typeof nestedValue !== "number" || !Number.isFinite(nestedValue)) {
+      throw invalidConfig(`Channel field "${key}.${nestedKey}" is invalid.`);
+    }
+  }
+}
+__name(assertNumberRecord, "assertNumberRecord");
+function assertSharedField(key, value) {
+  const enumValues = {
+    senderPolicy: /* @__PURE__ */ new Set(["allowlist", "pairing", "open"]),
+    dmPolicy: /* @__PURE__ */ new Set(["open", "disabled"]),
+    groupPolicy: /* @__PURE__ */ new Set(["disabled", "allowlist", "open"]),
+    sessionScope: /* @__PURE__ */ new Set(["user", "thread", "single"]),
+    dispatchMode: /* @__PURE__ */ new Set(["steer", "followup", "collect"]),
+    blockStreaming: /* @__PURE__ */ new Set(["on", "off"])
+  };
+  if (Object.hasOwn(enumValues, key)) {
+    if (typeof value !== "string" || !enumValues[key].has(value)) {
+      throw invalidConfig(`Channel field "${key}" has an invalid value.`);
+    }
+    return true;
+  }
+  if (["model", "cwd", "approvalMode", "instructions"].includes(key)) {
+    if (typeof value !== "string") {
+      throw invalidConfig(`Channel field "${key}" must be a string.`);
+    }
+    return true;
+  }
+  if (key === "allowedUsers") {
+    if (!Array.isArray(value) || value.some((item) => typeof item !== "string")) {
+      throw invalidConfig(`Channel field "${key}" must be a string array.`);
+    }
+    return true;
+  }
+  if (key === "groupHistoryLimit") {
+    if (typeof value !== "number" || !Number.isFinite(value)) {
+      throw invalidConfig(`Channel field "${key}" must be a number.`);
+    }
+    return true;
+  }
+  if (key === "identity") {
+    assertStringRecord(
+      key,
+      value,
+      /* @__PURE__ */ new Set(["id", "displayName", "description"])
+    );
+    return true;
+  }
+  if (key === "blockStreamingChunk") {
+    assertNumberRecord(key, value, /* @__PURE__ */ new Set(["minChars", "maxChars"]));
+    return true;
+  }
+  if (key === "blockStreamingCoalesce") {
+    assertNumberRecord(key, value, /* @__PURE__ */ new Set(["idleMs"]));
+    return true;
+  }
+  if (key === "memoryScope") {
+    if (!isRecord(value)) {
+      throw invalidConfig(`Channel field "${key}" must be an object.`);
+    }
+    for (const [nestedKey, nestedValue] of Object.entries(value)) {
+      const valid = nestedKey === "namespace" && typeof nestedValue === "string" || nestedKey === "mode" && nestedValue === "metadata-only";
+      if (!valid) {
+        throw invalidConfig(`Channel field "${key}.${nestedKey}" is invalid.`);
+      }
+    }
+    return true;
+  }
+  return false;
+}
+__name(assertSharedField, "assertSharedField");
+function assertDescriptorValue(field, value) {
+  const invalidEnvironment = typeof value === "string" && isEnvironmentReference(value) && field.envResolvable !== true;
+  if (invalidEnvironment) {
+    throw invalidConfig(
+      `Channel field "${field.key}" does not support environment references.`
+    );
+  }
+  const valid = (field.kind === "string" || field.kind === "secret") && typeof value === "string" && value.length > 0 || field.kind === "boolean" && typeof value === "boolean" || field.kind === "number" && typeof value === "number" && Number.isFinite(value) || field.kind === "enum" && typeof value === "string" && field.options?.some((option) => option.value === value) === true;
+  if (!valid) {
+    throw invalidConfig(`Channel field "${field.key}" has an invalid value.`);
+  }
+}
+__name(assertDescriptorValue, "assertDescriptorValue");
+function assertManagedConfig(config, previous, fields) {
+  const descriptorFields = new Map(fields.map((field) => [field.key, field]));
+  for (const [key, value] of Object.entries(config)) {
+    if (key === "type") continue;
+    const field = descriptorFields.get(key);
+    if (field) {
+      assertDescriptorValue(field, value);
+      continue;
+    }
+    if (assertSharedField(key, value)) continue;
+    if (!Object.hasOwn(previous, key) || !isDeepStrictEqual(previous[key], value)) {
+      throw invalidConfig(`Channel field "${key}" is not manageable.`);
+    }
+  }
+  for (const field of fields) {
+    if (!field.required) continue;
+    const value = config[field.key];
+    if (value === void 0 || value === null || value === "") {
+      throw invalidConfig(`Channel field "${field.key}" is required.`);
+    }
+  }
+}
+__name(assertManagedConfig, "assertManagedConfig");
+function validateSecretUpdate(update) {
+  if (!isRecord(update)) {
+    throw invalidSecret("Secret updates must be objects.");
+  }
+  const operation = update["operation"];
+  const keys = Object.keys(update).sort();
+  const valid = (operation === "preserve" || operation === "clear") && keys.length === 1 && keys[0] === "operation" || operation === "replace" && keys.length === 2 && keys[0] === "operation" && keys[1] === "value" && typeof update["value"] === "string" && update["value"].length > 0;
+  if (!valid) {
+    throw invalidSecret("Secret updates contain an invalid operation.");
+  }
+}
+__name(validateSecretUpdate, "validateSecretUpdate");
+function assertValidChannelSecretUpdates(updates) {
+  if (!isRecord(updates)) {
+    throw invalidSecret("Secret updates must be objects.");
+  }
+  for (const [key, update] of Object.entries(updates)) {
+    if (UNSAFE_OBJECT_KEYS.has(key)) {
+      throw invalidSecret(`Secret update ${JSON.stringify(key)} is invalid.`);
+    }
+    validateSecretUpdate(update);
+  }
+}
+__name(assertValidChannelSecretUpdates, "assertValidChannelSecretUpdates");
+function workspaceValues(workspaceCwd) {
+  const settings = loadSettings(workspaceCwd, { skipLoadEnvironment: true }).workspace.settings;
+  const rawChannels = isRecord(settings.channels) ? settings.channels : {};
+  const channels = {};
+  for (const [name, config] of Object.entries(rawChannels)) {
+    if (isRecord(config)) channels[name] = config;
+  }
+  const startupNames = Array.isArray(settings.serve?.channels) ? settings.serve.channels.filter(
+    (name) => typeof name === "string"
+  ) : [];
+  return { channels, startupNames };
+}
+__name(workspaceValues, "workspaceValues");
+var WorkspaceChannelSettingsStore = class {
+  constructor(workspaceCwd) {
+    this.workspaceCwd = workspaceCwd;
+  }
+  static {
+    __name(this, "WorkspaceChannelSettingsStore");
+  }
+  snapshot() {
+    const { channels, startupNames } = workspaceValues(this.workspaceCwd);
+    return {
+      revision: revisionOf(channels, startupNames),
+      channels: { ...channels },
+      startupNames: [...startupNames]
+    };
+  }
+  async upsert(name, options) {
+    assertUpsertChannelName(name);
+    const secretUpdates = options.secrets === void 0 ? {} : options.secrets;
+    assertValidChannelSecretUpdates(secretUpdates);
+    const plugin = await getPlugin(options.config.type);
+    if (!plugin?.management) {
+      throw new ChannelSettingsError(
+        "channel_settings_unmanageable",
+        `Channel type "${options.config.type}" does not provide safe management metadata.`
+      );
+    }
+    const secretKeys = new Set(
+      plugin.management.fields.filter((field) => field.kind === "secret").map((field) => field.key)
+    );
+    for (const key of Object.keys(secretUpdates)) {
+      if (!secretKeys.has(key)) {
+        throw invalidSecret(
+          `Channel type "${options.config.type}" does not declare "${key}" as a secret.`
+        );
+      }
+    }
+    for (const key of secretKeys) {
+      if (Object.hasOwn(options.config, key)) {
+        throw invalidSecret(
+          `Secret "${key}" must use an explicit preserve, replace, or clear operation.`
+        );
+      }
+    }
+    const current = this.assertRevision(options.expectedRevision);
+    const storedPrevious = current.channels[name] ?? {};
+    const previous = storedPrevious["type"] === options.config.type ? storedPrevious : {};
+    const nextConfig = { ...options.config };
+    for (const key of secretKeys) {
+      const update = secretUpdates[key] ?? { operation: "preserve" };
+      const value = applySecretUpdate(previous[key], update);
+      if (value !== void 0) nextConfig[key] = value;
+    }
+    assertManagedConfig(nextConfig, previous, plugin.management.fields);
+    const channels = { ...current.channels, [name]: nextConfig };
+    const workspaceFile = loadSettings(this.workspaceCwd, {
+      skipLoadEnvironment: true
+    }).workspace;
+    saveSettings(workspaceFile, { channels }, ["channels"], {
+      throwOnWriteFailure: true
+    });
+    return this.snapshot();
+  }
+  async remove(name, options) {
+    assertSafeChannelName(name);
+    const current = this.assertRevision(options.expectedRevision);
+    const channels = { ...current.channels };
+    delete channels[name];
+    const hasAllSentinel = current.startupNames.some(isAllStartupName);
+    const startupNames = hasAllSentinel ? Object.keys(channels).some(
+      (channelName) => !isAllStartupName(channelName)
+    ) ? ["all"] : [] : current.startupNames.filter((startupName) => startupName !== name);
+    const workspaceFile = loadSettings(this.workspaceCwd, {
+      skipLoadEnvironment: true
+    }).workspace;
+    saveSettings(
+      workspaceFile,
+      { channels, serve: { channels: startupNames } },
+      ["channels"],
+      { throwOnWriteFailure: true }
+    );
+    return this.snapshot();
+  }
+  async setStartupNames(names, options) {
+    for (const name of names) {
+      assertSafeChannelName(name);
+    }
+    this.assertRevision(options.expectedRevision);
+    const workspaceFile = loadSettings(this.workspaceCwd, {
+      skipLoadEnvironment: true
+    }).workspace;
+    saveSettings(
+      workspaceFile,
+      { serve: { channels: [...names] } },
+      ["serve", "channels"],
+      { throwOnWriteFailure: true }
+    );
+    return this.snapshot();
+  }
+  assertRevision(expectedRevision) {
+    const current = this.snapshot();
+    if (current.revision !== expectedRevision) {
+      throw new ChannelSettingsError(
+        "channel_settings_conflict",
+        "Channel settings changed; reload before trying again."
+      );
+    }
+    return current;
+  }
+};
+
+export {
+  ChannelSettingsError,
+  assertValidChannelSecretUpdates,
+  WorkspaceChannelSettingsStore
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-2SCDWPXI.js → chunk-TQCBGUHN.js}

@@ -5,10 +5,10 @@ import {
 } from "./chunk-DP3IHZGG.js";
 import {
   getNpmCliPath
-} from "./chunk-ZNAUOR2I.js";
+} from "./chunk-LNARWLZQ.js";
 import {
   t
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-VV6XU5L7.js";
 import {
   getPackageJson
 } from "./chunk-VJNBRRZG.js";

package/chunks/{chunk-LK7CHLVP.js → chunk-U4VTUMMK.js}

@@ -3,15 +3,6 @@
 import {
   CHANNEL_DELIVERY_ERROR_CODES
 } from "./chunk-BK2UNYWD.js";
-import {
-  redactLogCredentials
-} from "./chunk-M5GB774H.js";
-import {
-  sanitizeLogText
-} from "./chunk-RWTEFFPU.js";
-import {
-  stripAnsi
-} from "./chunk-TWPJO254.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -142,54 +133,6 @@ function isChannelDeliveryResultMessage(value) {
 }
 __name(isChannelDeliveryResultMessage, "isChannelDeliveryResultMessage");
 
-// packages/cli/src/serve/channel-worker-diagnostics.ts
-init_esbuild_shims();
-var WORKER_LOG_INVISIBLE_RE = new RegExp("[\\p{Cf}\\u2028\\u2029]|\\p{Variation_Selector}", "gu");
-var WORKER_LOG_CONTROL_RE = /[\x00-\x1f\x7f-\x9f]/g;
-function escapeRegExp(value) {
-  return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-__name(escapeRegExp, "escapeRegExp");
-function sensitiveEnvValues(env) {
-  const sensitiveKey = /(^|_)(TOKEN|SECRET|API_KEY|ACCESS_KEY|PRIVATE_KEY|CREDENTIAL|PASSWORD|PASSWD|PASSPHRASE|BASIC_AUTH|AUTH_TOKEN|AUTHORIZATION|SESSION_SECRET|SESSION_TOKEN|SESSION_KEY|SESSION_COOKIE|DSN|CONNECTION_STRING)($|_)/i;
-  return Object.entries(env).filter(([key, value]) => sensitiveKey.test(key) && value !== void 0).flatMap(([, value]) => {
-    const lines = value.split("\n").filter((line) => line.length >= 4);
-    return lines.length > 0 ? [value, ...lines] : [value];
-  }).filter((value) => value.length >= 4);
-}
-__name(sensitiveEnvValues, "sensitiveEnvValues");
-function normalizeWorkerDiagnostic(value) {
-  return stripAnsi(value).replace(WORKER_LOG_INVISIBLE_RE, "").replace(WORKER_LOG_CONTROL_RE, "");
-}
-__name(normalizeWorkerDiagnostic, "normalizeWorkerDiagnostic");
-function createWorkerDiagnosticRedactor(opts) {
-  const secretPatterns = [
-    ...new Set(
-      [
-        ...opts.daemonToken ? [opts.daemonToken] : [],
-        ...sensitiveEnvValues(opts.workerEnv)
-      ].flatMap((secret) => [
-        normalizeWorkerDiagnostic(secret),
-        normalizeWorkerDiagnostic(secret.replace(/\t/gu, " "))
-      ]).filter((secret) => secret.length >= 4)
-    )
-  ].sort((left, right) => right.length - left.length).map((secret) => new RegExp(escapeRegExp(secret), "g"));
-  return (value) => {
-    let redacted = value;
-    for (const secretPattern of secretPatterns) {
-      redacted = redacted.replace(secretPattern, "<redacted>");
-    }
-    return redactLogCredentials(redacted);
-  };
-}
-__name(createWorkerDiagnosticRedactor, "createWorkerDiagnosticRedactor");
-function sanitizeWorkerDiagnostic(value, maxLength, opts) {
-  const normalized = normalizeWorkerDiagnostic(value);
-  const redacted = createWorkerDiagnosticRedactor(opts)(normalized);
-  return sanitizeLogText(redacted, maxLength);
-}
-__name(sanitizeWorkerDiagnostic, "sanitizeWorkerDiagnostic");
-
 // packages/cli/src/serve/channel-worker-startup-ipc.ts
 init_esbuild_shims();
 var MAX_CHANNEL_STARTUP_FAILURES = 64;
@@ -285,9 +228,6 @@ export {
   createChannelDeliveryMessage,
   isChannelDeliveryMessage,
   isChannelDeliveryResultMessage,
-  normalizeWorkerDiagnostic,
-  createWorkerDiagnosticRedactor,
-  sanitizeWorkerDiagnostic,
   MAX_CHANNEL_STARTUP_FAILURES,
   MAX_CHANNEL_STARTUP_FAILURE_CHANNEL_LENGTH,
   MAX_CHANNEL_STARTUP_FAILURE_CODE_LENGTH,

package/chunks/{chunk-IKCX4CCL.js → chunk-U7TXFVUN.js}

@@ -381,18 +381,18 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
   try {
     if (authType === "openai" /* USE_OPENAI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-WMCU3O2H.js");
+        const { createOpenAIContentGenerator } = await import("./openaiContentGenerator-JPVXDTAO.js");
         return createOpenAIContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "qwen-oauth" /* QWEN_OAUTH */) {
-      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-OWLB5AKH.js");
+      const { getQwenOAuthClient: getQwenOauthClient } = await import("./qwenOAuth2-XGFI5XJG.js");
       try {
         const qwenClient = await getQwenOauthClient(
           config,
           isInitialAuth ? { requireCachedCredentials: true } : void 0
         );
         loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-          const { QwenContentGenerator } = await import("./qwenContentGenerator-HHCRK4SX.js");
+          const { QwenContentGenerator } = await import("./qwenContentGenerator-TICV2W2Z.js");
           return new QwenContentGenerator(qwenClient, generatorConfig, config);
         }, "loadBaseGenerator");
       } catch (error) {
@@ -403,12 +403,12 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       }
     } else if (authType === "anthropic" /* USE_ANTHROPIC */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-75BKLTSP.js");
+        const { createAnthropicContentGenerator } = await import("./anthropicContentGenerator-LXUXMOE7.js");
         return createAnthropicContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else if (authType === "gemini" /* USE_GEMINI */ || authType === "vertex-ai" /* USE_VERTEX_AI */) {
       loadBaseGenerator = /* @__PURE__ */ __name(async () => {
-        const { createGeminiContentGenerator } = await import("./geminiContentGenerator-AG4KB6CV.js");
+        const { createGeminiContentGenerator } = await import("./geminiContentGenerator-FQHPFZSR.js");
         return createGeminiContentGenerator(generatorConfig, config);
       }, "loadBaseGenerator");
     } else {
@@ -424,7 +424,7 @@ async function createContentGenerator(generatorConfig, config, isInitialAuth) {
       try {
         const [baseGenerator, { LoggingContentGenerator }] = await Promise.all([
           loadBaseGenerator(),
-          import("./loggingContentGenerator-HS3S5H3Q.js")
+          import("./loggingContentGenerator-WGM27QAW.js")
         ]);
         return new LoggingContentGenerator(
           baseGenerator,

package/chunks/{chunk-2NH6DYI4.js → chunk-V6VRAM7B.js}

@@ -2,20 +2,20 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-TPRQ7RZH.js";
+} from "./chunk-BYFNTGKI.js";
 import {
   CUSTOM_SANDBOX_IMAGE_ENV_VAR,
   HOST_UPDATE_RELAUNCH_ENV_VAR,
   SKIP_UPDATE_CHECK_ENV_VAR,
   requestUpdateOnExit
-} from "./chunk-Y34KJKDC.js";
+} from "./chunk-C3NS4F2Q.js";
 import {
   loadUndici
 } from "./chunk-3Z43GZUQ.js";
 import {
   IdeClient,
   getAllProviderBaseUrls
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import {
   detectRuntime,
   getOrCreateSharedDispatcher,
@@ -24,7 +24,7 @@ import {
 } from "./chunk-2JZBVYTU.js";
 import {
   initializeTelemetry
-} from "./chunk-MB4MZHMJ.js";
+} from "./chunk-SRZ6DXVG.js";
 import {
   createDebugLogger
 } from "./chunk-NL7LTRLR.js";
@@ -231,11 +231,11 @@ function startPostRenderPrefetches(config, settings, options = {}) {
         { updateEventEmitter },
         { t }
       ] = await Promise.all([
-        import("./updateCheck-RKL6M5XN.js"),
-        import("./handleAutoUpdate-6DBEZYPV.js"),
-        import("./installationInfo-6O2YAA52.js"),
+        import("./updateCheck-WUJGHWZZ.js"),
+        import("./handleAutoUpdate-2CZQRJ66.js"),
+        import("./installationInfo-5UUQJI6Y.js"),
         import("./updateEventEmitter-5MKC7BLQ.js"),
-        import("./i18n-VUJJZIMU.js")
+        import("./i18n-XEQVMRKN.js")
       ]);
       const updateCheckSkippedMessage = /* @__PURE__ */ __name((error) => t("Update check skipped ({{reason}}) \u2014 run /update to retry.", {
         reason: describeUpdateCheckFailure(error)
@@ -308,7 +308,7 @@ ${t(
         state: "connecting"
       });
       try {
-        const { connectIdeForStartup } = await import("./initializer-UWAK5U5O.js");
+        const { connectIdeForStartup } = await import("./initializer-OVGZ4FLY.js");
         await withTimeout(
           connectIdeForStartup(config),
           "ide_connect",
@@ -332,7 +332,7 @@ ${t(
   }
   if (config.isInteractive()) {
     runDeferredTask("background_housekeeping", async () => {
-      const { startBackgroundHousekeeping } = await import("./scheduler-G2ZS2Z7E.js");
+      const { startBackgroundHousekeeping } = await import("./scheduler-RS2I6RU5.js");
       startBackgroundHousekeeping(config, settings);
     });
   }

package/chunks/{chunk-Z2BC6UJ5.js → chunk-VCBZUOSI.js}

@@ -13,7 +13,7 @@ import {
 } from "./chunk-OWAK7LMW.js";
 import {
   ideContextStore
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import {
   atomicWriteFileSync
 } from "./chunk-A5L3JMUA.js";

package/chunks/{chunk-IKYJHJNF.js → chunk-VFSJ5VRH.js}

@@ -6,7 +6,7 @@ import {
 import {
   JsonFormatter,
   parseAndFormatApiError
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import {
   FatalBudgetExceededError,
   FatalCancellationError,
@@ -15,7 +15,7 @@ import {
 } from "./chunk-NL7LTRLR.js";
 import {
   runExitCleanup
-} from "./chunk-PWVFN2LF.js";
+} from "./chunk-B4UMZKMU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-LKEJ26GS.js → chunk-VV6XU5L7.js}

@@ -5,7 +5,7 @@ import {
 } from "./chunk-OWAK7LMW.js";
 import {
   resolveBundleDir
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-DM4Q4JJH.js";
 import {
   Storage
 } from "./chunk-NL7LTRLR.js";

package/chunks/{chunk-7ZCNENPP.js → chunk-W4CQXHT6.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolvePath
-} from "./chunk-RWTEFFPU.js";
+} from "./chunk-ML52PL6O.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-HTR4WV6U.js → chunk-W4RQUHY3.js}

@@ -322,6 +322,36 @@ var require_src = __commonJS({
   }
 });
 
+// packages/core/src/utils/safeJsonStringify.ts
+init_esbuild_shims();
+function safeJsonStringify(obj, space) {
+  const ancestors = [];
+  return JSON.stringify(
+    obj,
+    function(_key, value) {
+      if (typeof value !== "object" || value === null) {
+        return value;
+      }
+      while (ancestors.length > 0 && ancestors[ancestors.length - 1] !== this) {
+        ancestors.pop();
+      }
+      if (ancestors.includes(value)) {
+        return "[Circular]";
+      }
+      ancestors.push(value);
+      return value;
+    },
+    space
+  );
+}
+__name(safeJsonStringify, "safeJsonStringify");
+
 export {
-  require_src
+  require_src,
+  safeJsonStringify
 };
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-ETSW4KLJ.js → chunk-WDSWXQU3.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   STATUS_SCHEMA_VERSION
-} from "./chunk-VIA5XA4U.js";
+} from "./chunk-KU5XMLDK.js";
 import {
   detectRuntime,
   redactProxyCredentials