@qwen-code/qwen-code 0.23.3 → 0.23.4-dev.codemode-responses.20260914.87437db784

package/chunks/{chunk-IAEXTMED.js → chunk-GNV2SFO7.js}

@@ -4,7 +4,7 @@ import {
   matches,
   nextFireTime,
   parseCron
-} from "./chunk-IRH27ZC2.js";
+} from "./chunk-5EZRLTLQ.js";
 import {
   humanReadableCron
 } from "./chunk-QHWCP53L.js";
@@ -13,6 +13,7 @@ import {
   addCronTask,
   annotateCronRunSession,
   appendCronRun,
+  cronTaskSessionDeletionId,
   generateCronTaskId,
   getCronFilePath,
   readCronTasks,
@@ -20,10 +21,10 @@ import {
   taskHasLegacyCondition,
   taskHasLegacyRunMode,
   updateCronTasks
-} from "./chunk-F53KKZUD.js";
+} from "./chunk-3LMDSCLU.js";
 import {
   ToolNames
-} from "./chunk-TP6FYVQT.js";
+} from "./chunk-RSWBT7AZ.js";
 import {
   Storage,
   createDebugLogger,
@@ -301,6 +302,15 @@ var CronScheduler = class {
   // eligible to fire them. Cleared on stop so a later enable still treats
   // genuinely overdue work as missed.
   armedDurableOneShots = /* @__PURE__ */ new Set();
+  // Exact persisted snapshots for active per-run one-shots. The tick removes
+  // such a task before its async fresh-session dispatch finishes; retain the
+  // original so a rejected dispatch can put the unexecuted task back without
+  // dropping route-only fields such as session ownership.
+  restorablePerRunOneShots = /* @__PURE__ */ new Map();
+  consumedPerRunOneShots = /* @__PURE__ */ new Set();
+  // The durable deletion generation observed by the task-file mutation that
+  // removed each consumed one-shot.
+  consumedPerRunRemovalGenerations = /* @__PURE__ */ new Map();
   // Ids of legacy tasks (a pre-removal `isolated` task with a `condition`
   // precondition) already reported as skipped, so the fail-closed remediation
   // breadcrumb is logged once per task rather than on every file reload.
@@ -504,7 +514,12 @@ var CronScheduler = class {
    */
   async delete(id) {
     const job = this.jobs.get(id);
-    if (!job) return this.cancelWakeup(id);
+    if (!job) {
+      this.restorablePerRunOneShots.delete(id);
+      this.consumedPerRunOneShots.delete(id);
+      this.consumedPerRunRemovalGenerations.delete(id);
+      return this.cancelWakeup(id);
+    }
     this.jobs.delete(id);
     if (job.durable && this.projectRoot) {
       this.pendingRemoval.add(id);
@@ -516,6 +531,9 @@ var CronScheduler = class {
         throw error;
       }
     }
+    this.restorablePerRunOneShots.delete(id);
+    this.consumedPerRunOneShots.delete(id);
+    this.consumedPerRunRemovalGenerations.delete(id);
     this.armedDurableOneShots.delete(id);
     return true;
   }
@@ -705,6 +723,11 @@ var CronScheduler = class {
     }
     const diskIds = new Set(tasks.map((t) => t.id));
     for (const id of this.pendingAdd) diskIds.add(id);
+    for (const id of this.restorablePerRunOneShots.keys()) {
+      if (!diskIds.has(id) && !this.consumedPerRunOneShots.has(id)) {
+        this.restorablePerRunOneShots.delete(id);
+      }
+    }
     for (const job of this.jobs.values()) {
       if (job.durable && !diskIds.has(job.id)) {
         this.jobs.delete(job.id);
@@ -730,6 +753,15 @@ var CronScheduler = class {
         job.lastFiredAt = Math.max(existing.lastFiredAt, job.lastFiredAt ?? 0);
       }
       this.jobs.set(task.id, job);
+      if (!task.recurring && task.sessionMode === "per_run") {
+        this.restorablePerRunOneShots.set(task.id, {
+          task,
+          index: read.findIndex((candidate) => candidate.id === task.id)
+        });
+      } else {
+        this.restorablePerRunOneShots.delete(task.id);
+        this.consumedPerRunOneShots.delete(task.id);
+      }
       if (!task.recurring && this.#shouldFireDurable(job)) {
         this.armedDurableOneShots.add(task.id);
       } else {
@@ -958,6 +990,10 @@ var CronScheduler = class {
   /** Attributes an already-persisted per-run fire to the session it ran in,
    * and/or marks its fresh-session creation as failed. */
   async annotateRunSession(taskId, firedAt, outcome) {
+    if (outcome.sessionId && this.consumedPerRunOneShots.delete(taskId)) {
+      this.restorablePerRunOneShots.delete(taskId);
+      this.consumedPerRunRemovalGenerations.delete(taskId);
+    }
     if (!this.projectRoot) return;
     await Promise.resolve();
     await this.pendingPersist;
@@ -968,6 +1004,84 @@ var CronScheduler = class {
       )
     );
   }
+  /** Pauses and records a durable per-run one-shot that never dispatched. */
+  async restoreConsumedOneShot(taskId) {
+    const projectRoot = this.projectRoot;
+    const snapshot = this.restorablePerRunOneShots.get(taskId);
+    const firedAt = snapshot?.task.lastFiredAt;
+    if (!projectRoot || !snapshot || firedAt == null || !this.consumedPerRunOneShots.has(taskId)) {
+      return false;
+    }
+    await Promise.resolve();
+    await this.pendingPersist;
+    const removalGeneration = this.consumedPerRunRemovalGenerations.get(taskId);
+    if (!this.consumedPerRunOneShots.has(taskId) || removalGeneration === void 0) {
+      this.restorablePerRunOneShots.delete(taskId);
+      this.consumedPerRunOneShots.delete(taskId);
+      this.consumedPerRunRemovalGenerations.delete(taskId);
+      return false;
+    }
+    this.armedDurableOneShots.delete(taskId);
+    let restoreGenerations = /* @__PURE__ */ new Map();
+    let restored = false;
+    try {
+      await updateCronTasks(
+        projectRoot,
+        (tasks) => {
+          if ([...removalGeneration].some(
+            ([id, generation]) => restoreGenerations.get(id) !== generation
+          ))
+            return tasks;
+          const existing = tasks.findIndex((task) => task.id === taskId);
+          const current = tasks[existing] ?? snapshot.task;
+          const failed = {
+            ...current,
+            enabled: false,
+            lastFiredAt: firedAt,
+            runs: appendCronRun(current.runs, {
+              at: firedAt,
+              kind: "scheduled",
+              sessionDispatchFailed: true
+            })
+          };
+          restored = true;
+          if (existing !== -1) {
+            return tasks.map(
+              (task, index) => index === existing ? failed : task
+            );
+          }
+          const next = [...tasks];
+          next.splice(Math.min(snapshot.index, next.length), 0, failed);
+          return next;
+        },
+        {
+          observeDeletionIds: [...removalGeneration.keys()],
+          onDeletionGenerations: /* @__PURE__ */ __name((generations) => {
+            restoreGenerations = generations;
+          }, "onDeletionGenerations")
+        }
+      );
+    } catch (error) {
+      this.restorablePerRunOneShots.delete(taskId);
+      this.consumedPerRunOneShots.delete(taskId);
+      this.consumedPerRunRemovalGenerations.delete(taskId);
+      console.warn(
+        `CronScheduler: could not restore scheduled one-shot task ${taskId} after its run failed to dispatch \u2014 the task may be gone from disk with no recorded run.`
+      );
+      throw error;
+    }
+    if (!restored) {
+      this.restorablePerRunOneShots.delete(taskId);
+      this.consumedPerRunOneShots.delete(taskId);
+      this.consumedPerRunRemovalGenerations.delete(taskId);
+      return false;
+    }
+    this.pendingRemoval.delete(taskId);
+    this.jobs.delete(taskId);
+    this.consumedPerRunOneShots.delete(taskId);
+    this.consumedPerRunRemovalGenerations.delete(taskId);
+    return true;
+  }
   /**
    * Starts the scheduler tick. Calls `onFire` when a job is due.
    * Only fires when called — does not auto-fire missed intervals.
@@ -1122,12 +1236,41 @@ var CronScheduler = class {
         this.armedDurableOneShots.delete(id);
       }
       const removed = new Set(removedIds);
+      const removedByFire = /* @__PURE__ */ new Set();
+      let removalGenerations = /* @__PURE__ */ new Map();
       const guarded = [...firedAt.keys()];
       this.markFirePersistPending(guarded);
+      const recordRemovalGenerations = /* @__PURE__ */ __name(() => {
+        for (const id of removedByFire) {
+          const generation = removalGenerations.get(id);
+          if (generation !== void 0 && this.consumedPerRunOneShots.has(id)) {
+            const observed = /* @__PURE__ */ new Map([[id, generation]]);
+            const sessionId = this.restorablePerRunOneShots.get(id)?.task.sessionId;
+            if (sessionId) {
+              const key = cronTaskSessionDeletionId(sessionId);
+              const sessionGeneration = removalGenerations.get(key);
+              if (sessionGeneration === void 0) continue;
+              observed.set(key, sessionGeneration);
+            }
+            this.consumedPerRunRemovalGenerations.set(id, observed);
+          }
+        }
+      }, "recordRemovalGenerations");
       this.trackPersist(
         updateCronTasks(
           this.projectRoot,
-          (tasks) => tasks.filter((t) => !removed.has(t.id)).map((t) => {
+          (tasks) => tasks.filter((t) => {
+            if (!removed.has(t.id)) return true;
+            removedByFire.add(t.id);
+            const snapshot = this.restorablePerRunOneShots.get(t.id);
+            if (snapshot) {
+              snapshot.task = {
+                ...t,
+                lastFiredAt: snapshot.task.lastFiredAt
+              };
+            }
+            return false;
+          }).map((t) => {
             const stamp = firedAt.get(t.id);
             if (stamp === void 0 || (t.lastFiredAt ?? 0) >= stamp)
               return t;
@@ -1142,8 +1285,22 @@ var CronScheduler = class {
                 ...t.sessionMode !== "per_run" && this.sessionId ? { sessionId: this.sessionId } : {}
               })
             };
-          })
-        ).finally(() => {
+          }),
+          {
+            observeDeletionIds: /* @__PURE__ */ __name((tasks) => [
+              ...removedIds,
+              ...tasks.flatMap(
+                (task) => removed.has(task.id) && task.sessionId ? [cronTaskSessionDeletionId(task.sessionId)] : []
+              )
+            ], "observeDeletionIds"),
+            onDeletionGenerations: /* @__PURE__ */ __name((generations) => {
+              removalGenerations = generations;
+            }, "onDeletionGenerations")
+          }
+        ).then(recordRemovalGenerations, (error) => {
+          recordRemovalGenerations();
+          throw error;
+        }).finally(() => {
           this.clearFirePersistPending(guarded);
         })
       );
@@ -1186,6 +1343,13 @@ var CronScheduler = class {
     if (!job.recurring || expired) {
       this.jobs.delete(job.id);
     }
+    if (!job.recurring && job.durable && job.sessionMode === "per_run") {
+      this.consumedPerRunOneShots.add(job.id);
+      const snapshot = this.restorablePerRunOneShots.get(job.id);
+      if (snapshot) {
+        snapshot.task = { ...snapshot.task, lastFiredAt: matchedMinuteMs };
+      }
+    }
     if (this.onFire) {
       this.onFire(job);
     }
@@ -1274,6 +1438,8 @@ function durableTaskToJob(task, recurringMaxAgeMs, existing) {
     durable: true,
     ...task.sessionId ? { boundSessionId: task.sessionId } : {},
     ...task.sessionMode ? { sessionMode: task.sessionMode } : {},
+    ...task.modelServiceId ? { modelServiceId: task.modelServiceId } : {},
+    ...task.groupId ? { groupId: task.groupId } : {},
     ...task.name ? { name: task.name } : {},
     ...task.delivery && task.sessionId ? { delivery: task.delivery } : {}
   };

package/chunks/{chunk-CXTPVBFA.js → chunk-GSS4SZNG.js}

@@ -8,18 +8,18 @@ import {
 } from "./chunk-JL6APGBX.js";
 import {
   buildSessionAwareFetch
-} from "./chunk-NOO4QFXM.js";
+} from "./chunk-C75BXMPM.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
-} from "./chunk-ZHKTKHMO.js";
+} from "./chunk-7MIBD3LG.js";
 import {
   REASONING_EFFORT_TIERS,
   clampReasoningEffort,
   getGptReasoningCapabilities,
   isReasoningEffortPlaceholder,
   parseModelReasoningCapabilities
-} from "./chunk-3FPYT6QC.js";
+} from "./chunk-ARDHE6MM.js";
 import {
   defaultOutputCeiling,
   hasExplicitOutputLimit,
@@ -480,16 +480,20 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
    *
    * This method applies DashScope-specific configurations including:
    * - Cache control for the system message, last tool message (when tools are configured),
-   *   and the latest history message
+   *   and the latest history message — or, when a reattach region trails the
+   *   conversation, the last stable block before it
    * - Output token limits based on model capabilities
    * - Vision model specific parameters (vl_high_resolution_images)
    * - Request metadata for session tracking
    *
    * @param request - The original chat completion request parameters
    * @param userPromptId - Unique identifier for the user prompt for session tracking
+   * @param reattachBlockCount - Number of trailing blocks in the last message that
+   *   belong to the regenerated reattach region; the conversation cache breakpoint
+   *   is placed before them. Defaults to 0 (last block of the last message).
    * @returns Configured request with DashScope-specific parameters applied
    */
-  buildRequest(request, userPromptId) {
+  buildRequest(request, userPromptId, reattachBlockCount = 0) {
     let messages = request.messages;
     let tools = request.tools;
     const flattenPlainTextForGlm = this.isGlmModel(request.model) && !this.hasFunctionCallingContext(request);
@@ -498,7 +502,8 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     } else if (this.shouldEnableCacheControl()) {
       const { messages: updatedMessages, tools: updatedTools } = this.addDashScopeCacheControl(
         request,
-        request.stream ? "all" : "system_only"
+        request.stream ? "all" : "system_only",
+        reattachBlockCount
       );
       messages = updatedMessages;
       tools = updatedTools;
@@ -530,7 +535,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
         ...requestParams,
         messages,
         ...tools ? { tools } : {},
-        ...this.buildMetadata(userPromptId) || {},
+        ...this.buildRequestMetadata(request.model, userPromptId),
         ...dashscopeExtras2
       };
       if (hasQwenEffortConfig && "reasoning" in visionResult) {
@@ -552,7 +557,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       // Preserve all original parameters including sampling params and adjusted max_tokens
       messages,
       ...tools ? { tools } : {},
-      ...this.buildMetadata(userPromptId) || {},
+      ...this.buildRequestMetadata(request.model, userPromptId),
       ...dashscopeExtras
     };
     if (hasQwenEffortConfig && "reasoning" in result) {
@@ -737,6 +742,49 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     }
   }
   conflictingKnobDropWarned = false;
+  /**
+   * DashScope is an aggregating gateway: a non-qwen model (e.g. `ZHIPU/GLM-...`)
+   * reached through the same endpoint has its request forwarded to that vendor's
+   * own backend, `metadata` object included. Those backends type `metadata` as a
+   * string, so the object fails to deserialize and the request is rejected with a
+   * flat 400, making the model unusable through Qwen Code. `metadata` is a
+   * platform-private tracing field (sessionId / promptId / channel) that only
+   * means anything to DashScope's own inference path, so gate it on the wire model
+   * the same way `buildQwenEffortConfig` gates the qwen-only thinking knobs, for
+   * the same stated reason: qwen-specific fields must not leak to a non-qwen model
+   * sharing the endpoint.
+   *
+   * This is orthogonal to which *origins* count as DashScope-compatible, so the
+   * `*.alicloudapi.com` recognition added in #9103 is untouched: a qwen model
+   * behind such a gateway still ships metadata.
+   */
+  buildRequestMetadata(model, userPromptId) {
+    if (!this.shouldSendRequestMetadata(model)) {
+      return {};
+    }
+    return this.buildMetadata(userPromptId) || {};
+  }
+  /**
+   * Auto by default: qwen-family wire models only, per the gateway reasoning on
+   * {@link buildRequestMetadata}. The client cannot tell a forwarded request from
+   * one DashScope serves itself, so an explicit `enableRequestMetadata` wins in
+   * both directions: `true` restores the field for a non-qwen model served
+   * first-party whose tracing still matters, `false` suppresses it everywhere.
+   * Read only from the provider's own config, never the session's. A
+   * side-model generator is built with its own per-model config but shares
+   * the session `Config`, and a cross-provider agent config deliberately
+   * clears this field, so any session fallback would let the main model's
+   * value decide a different model's request. On the main route the provider
+   * config is the same object the qwen-oauth hot switch mutates in place, so
+   * nothing is latched here.
+   */
+  shouldSendRequestMetadata(model) {
+    const configured = this.contentGeneratorConfig.enableRequestMetadata;
+    if (typeof configured === "boolean") {
+      return configured;
+    }
+    return isQwenFamilyWireModel(this.resolveWireModel(model));
+  }
   buildMetadata(userPromptId) {
     const channel = this.cliConfig.getChannel?.();
     return {
@@ -753,20 +801,25 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
   /**
    * Add cache control flag to specified message(s) for DashScope providers
    */
-  addDashScopeCacheControl(request, cacheControl) {
+  addDashScopeCacheControl(request, cacheControl, reattachBlockCount = 0) {
     const messages = request.messages;
     const systemIndex = messages.findIndex((msg) => msg.role === "system");
     const lastIndex = messages.length - 1;
+    const stableBlock = reattachBlockCount > 0 && lastIndex >= 0 ? this.lastStableBlock(messages, reattachBlockCount) : { messageIndex: lastIndex, excludeTail: 0 };
     const updatedMessages = messages.length === 0 ? messages : messages.map((message, index) => {
+      const isConversationAnchor = stableBlock?.messageIndex === index && cacheControl === "all";
       const shouldAddCacheControl = Boolean(
-        index === systemIndex && systemIndex !== -1 || index === lastIndex && cacheControl === "all"
+        index === systemIndex && systemIndex !== -1 || isConversationAnchor
       );
       if (!shouldAddCacheControl || !("content" in message) || message.content === null || message.content === void 0) {
         return message;
       }
       return {
         ...message,
-        content: this.addCacheControlToContent(message.content)
+        content: this.addCacheControlToContent(
+          message.content,
+          isConversationAnchor && stableBlock ? stableBlock.excludeTail : 0
+        )
       };
     });
     const updatedTools = cacheControl === "all" && request.tools?.length ? this.addCacheControlToTools(request.tools) : request.tools;
@@ -775,6 +828,25 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       tools: updatedTools
     };
   }
+  /**
+   * Locate the last block that is not part of the trailing reattach region,
+   * walking back through messages as needed. Returns the owning message index
+   * plus how many trailing blocks of that message to skip when stamping the
+   * conversation `cache_control` breakpoint.
+   */
+  lastStableBlock(messages, reattachBlockCount) {
+    let remaining = reattachBlockCount;
+    for (let index = messages.length - 1; index >= 0; index--) {
+      const content = messages[index].content;
+      const blockCount = typeof content === "string" ? content.length > 0 ? 1 : 0 : Array.isArray(content) ? content.length : 0;
+      if (blockCount === 0) continue;
+      if (blockCount > remaining) {
+        return { messageIndex: index, excludeTail: remaining };
+      }
+      remaining -= blockCount;
+    }
+    return void 0;
+  }
   addCacheControlToTools(tools) {
     if (tools.length === 0) {
       return tools;
@@ -790,9 +862,9 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
   /**
    * Add cache control to message content, handling both string and array formats
    */
-  addCacheControlToContent(content) {
+  addCacheControlToContent(content, excludeTail = 0) {
     const contentArray = this.normalizeContentToArray(content);
-    return this.addCacheControlToContentArray(contentArray);
+    return this.addCacheControlToContentArray(contentArray, excludeTail);
   }
   /**
    * Normalize content to array format
@@ -809,14 +881,25 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     return [...content];
   }
   /**
-   * Add cache control to the content array
+   * Add cache control to the content array, skipping `excludeTail` trailing
+   * blocks (the reattach region) so the breakpoint lands on the last stable
+   * block instead of a regenerated trailing image.
    */
-  addCacheControlToContentArray(contentArray) {
+  addCacheControlToContentArray(contentArray, excludeTail = 0) {
     if (contentArray.length === 0) {
       return contentArray;
     }
-    const lastItem = contentArray[contentArray.length - 1];
-    contentArray[contentArray.length - 1] = {
+    let targetIndex = contentArray.length - 1 - excludeTail;
+    if (targetIndex < 0) {
+      return contentArray;
+    }
+    if (excludeTail > 0) {
+      while (targetIndex > 0 && contentArray[targetIndex].type !== "text") {
+        targetIndex -= 1;
+      }
+    }
+    const lastItem = contentArray[targetIndex];
+    contentArray[targetIndex] = {
       ...lastItem,
       cache_control: { type: "ephemeral" }
     };

package/chunks/chunk-GXN7DWZZ.js

@@ -0,0 +1,154 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  getNestedProperty,
+  getPersistScopeForModelSelection
+} from "./chunk-J73WJIMT.js";
+import {
+  getHomeEnvFallbackVars
+} from "./chunk-A6YU6R5N.js";
+import {
+  writeWithBackupSync
+} from "./chunk-NTCFKGQF.js";
+import {
+  resolveEnvVarsInObject
+} from "./chunk-65I7S4Z3.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/config/loadedSettingsAdapter.ts
+init_esbuild_shims();
+import * as fs from "node:fs";
+function preservePlaceholders(value, resolved, original) {
+  if (typeof original === "string" && value === resolved) return original;
+  if (Array.isArray(value) && Array.isArray(resolved) && Array.isArray(original)) {
+    return value.map(
+      (entry, index) => preservePlaceholders(entry, resolved[index], original[index])
+    );
+  }
+  if (value && resolved && original && typeof value === "object" && !Array.isArray(value) && typeof resolved === "object" && !Array.isArray(resolved) && typeof original === "object" && !Array.isArray(original)) {
+    return Object.fromEntries(
+      Object.entries(value).map(([key, entry]) => [
+        key,
+        preservePlaceholders(
+          entry,
+          resolved[key],
+          original[key]
+        )
+      ])
+    );
+  }
+  return value;
+}
+__name(preservePlaceholders, "preservePlaceholders");
+function createLoadedSettingsAdapter(settings, scope) {
+  const persistScope = scope ?? getPersistScopeForModelSelection(settings);
+  const settingsFile = settings.forScope(persistScope);
+  let fileSnapshot;
+  let settingsSnapshot = null;
+  let originalSnapshot = null;
+  return {
+    getValue(key) {
+      return getNestedProperty(settings.merged, key);
+    },
+    setValue(key, value) {
+      for (const part of key.split(".")) {
+        if (part === "__proto__" || part === "constructor" || part === "prototype") {
+          throw new Error(
+            `Refusing to write settings key with reserved segment: ${key}`
+          );
+        }
+      }
+      const provider = key.startsWith("modelProviders.") && key.split(".").length === 2 ? key.slice("modelProviders.".length) : void 0;
+      if (!provider || !Array.isArray(value)) {
+        settings.setValue(persistScope, key, value);
+        return;
+      }
+      const previous = settings.merged.modelProviders?.[provider];
+      const source = [
+        "System" /* System */,
+        ...settings.isTrusted ? ["Workspace" /* Workspace */] : [],
+        "User" /* User */,
+        "SystemDefaults" /* SystemDefaults */
+      ].map(
+        (source2) => settings.forScope(source2).originalSettings.modelProviders
+      ).find((providers) => providers && Object.hasOwn(providers, provider));
+      const raw = source?.[provider];
+      const models = value;
+      const persisted = !Array.isArray(previous) || !Array.isArray(raw) ? models : models.map((model) => {
+        if (!model) return model;
+        const matches = previous.flatMap(
+          (entry, index2) => entry?.id === model.id && entry.baseUrl === model.baseUrl ? [index2] : []
+        );
+        if (matches.length > 1 && JSON.stringify(previous) !== JSON.stringify(raw)) {
+          throw new Error(
+            "Cannot preserve placeholders in an ambiguous model configuration. Remove duplicate model entries first."
+          );
+        }
+        const index = matches[0];
+        return index === void 0 ? model : preservePlaceholders(model, previous[index], raw[index]);
+      });
+      settings.setValue(persistScope, key, persisted);
+      settingsFile.settings.modelProviders = {
+        ...settingsFile.settings.modelProviders,
+        [provider]: resolveEnvVarsInObject(persisted, getHomeEnvFallbackVars())
+      };
+      settings.recomputeMerged();
+    },
+    getModelProviders() {
+      return settings.merged.modelProviders ?? {};
+    },
+    persist() {
+    },
+    backup() {
+      const contents = fs.existsSync(settingsFile.path) ? fs.readFileSync(settingsFile.path, "utf8") : null;
+      settingsSnapshot = structuredClone(settingsFile.settings);
+      originalSnapshot = structuredClone(settingsFile.originalSettings);
+      fileSnapshot = contents;
+    },
+    restore() {
+      if (fileSnapshot === void 0) return;
+      try {
+        if (fileSnapshot === null) {
+          fs.rmSync(settingsFile.path, { force: true });
+        } else {
+          writeWithBackupSync(settingsFile.path, fileSnapshot);
+        }
+      } finally {
+        if (settingsSnapshot !== null) {
+          settingsFile.settings = settingsSnapshot;
+        }
+        if (originalSnapshot !== null) {
+          settingsFile.originalSettings = originalSnapshot;
+        }
+        settings.recomputeMerged();
+      }
+    },
+    cleanupBackup() {
+      fileSnapshot = void 0;
+      settingsSnapshot = null;
+      originalSnapshot = null;
+    }
+  };
+}
+__name(createLoadedSettingsAdapter, "createLoadedSettingsAdapter");
+
+export {
+  createLoadedSettingsAdapter
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ *
+ * Adapter that lets core's `applyProviderInstallPlan` write through
+ * `LoadedSettings` while preserving CLI-specific guarantees:
+ * - scope resolution via `getPersistScopeForModelSelection`
+ * - original file contents for transaction rollback
+ * - in-memory snapshot of `settings` / `originalSettings` for rollback
+ * - merged-settings recomputation after restore
+ */

package/chunks/{chunk-SODMFNAR.js → chunk-H23UWPF7.js}

@@ -5,26 +5,26 @@ import {
 } from "./chunk-57OAHC2Y.js";
 import {
   loadSettings
-} from "./chunk-7BXXIQG4.js";
+} from "./chunk-J73WJIMT.js";
 import {
   getCurrentLanguage,
   t
-} from "./chunk-VZUCTJ2P.js";
+} from "./chunk-I6YJZGHS.js";
 import {
   isWorkspaceTrusted
-} from "./chunk-53GWJOLP.js";
+} from "./chunk-NTCFKGQF.js";
 import {
   ExtensionManager,
   getExtensionDescription,
   getExtensionDisplayName,
   require_prompts
-} from "./chunk-N7VWZDWW.js";
+} from "./chunk-CFSBWJBB.js";
 import {
   stripAnsi
 } from "./chunk-TWPJO254.js";
 import {
   redactUrlCredentials
-} from "./chunk-W5ZQMAEM.js";
+} from "./chunk-4Y2I3CI3.js";
 import {
   writeStdoutLine
 } from "./chunk-7FA2II6K.js";