@qwen-code/qwen-code 0.23.1-preview.1 → 0.23.1

package/chunks/{chunk-43NOB5NM.js → chunk-HIXUUCGY.js}

@@ -2,12 +2,13 @@
 "use strict";
 import {
   isCommandAvailable
-} from "./chunk-OECNP26L.js";
+} from "./chunk-N6S3NUYJ.js";
 import {
   fileExists,
   isWithinRoot
 } from "./chunk-J6MB5ZHZ.js";
 import {
+  atomicWriteFile,
   atomicWriteJSON
 } from "./chunk-XFFRI3WM.js";
 import {
@@ -171,11 +172,17 @@ async function addWorktreeSessionMarkerExclude(worktreePath) {
       existing = await fs2.readFile(excludePath, "utf8");
     } catch {
     }
-    const rule = WORKTREE_SESSION_FILE;
-    if (!existing.split(/\r?\n/).includes(rule)) {
-      const sep = existing.length === 0 || existing.endsWith("\n") ? "" : "\n";
-      await fs2.writeFile(excludePath, `${existing}${sep}${rule}
-`, "utf8");
+    const rules = [WORKTREE_SESSION_FILE, `${WORKTREE_SESSION_FILE}.*.tmp`];
+    let next = existing;
+    for (const rule of rules) {
+      if (!next.split(/\r?\n/).includes(rule)) {
+        const sep = next.length === 0 || next.endsWith("\n") ? "" : "\n";
+        next = `${next}${sep}${rule}
+`;
+      }
+    }
+    if (next !== existing) {
+      await fs2.writeFile(excludePath, next, "utf8");
     }
   } catch {
   }
@@ -190,15 +197,32 @@ async function writeWorktreeSessionMarker(worktreePath, sessionId) {
   await addWorktreeSessionMarkerExclude(worktreePath);
 }
 __name(writeWorktreeSessionMarker, "writeWorktreeSessionMarker");
-async function createWorktreeSessionMarkerExclusive(worktreePath, sessionId) {
-  if (sessionId.length === 0 || Buffer.byteLength(sessionId, "utf8") > WORKTREE_SESSION_MARKER_MAX_BYTES || sessionId.trim() !== sessionId) {
-    throw new Error("Invalid worktree session marker owner");
+var WorktreeMarkerCommittedError = class extends Error {
+  static {
+    __name(this, "WorktreeMarkerCommittedError");
   }
+  committedOwner;
+  constructor(committedOwner, options) {
+    super(
+      `Worktree session marker committed for ${committedOwner}; the post-commit close failed`,
+      options
+    );
+    this.name = "WorktreeMarkerCommittedError";
+    this.committedOwner = committedOwner;
+  }
+};
+async function createWorktreeSessionMarkerExclusive(worktreePath, sessionId) {
+  assertValidWorktreeSessionMarkerOwner(sessionId);
   const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  const stagedPath = `${markerPath}.${randomBytes(6).toString("hex")}.tmp`;
   const flags = nodeFs.constants.O_WRONLY | nodeFs.constants.O_CREAT | nodeFs.constants.O_EXCL | (nodeFs.constants.O_NOFOLLOW ?? 0);
-  const handle = await fs2.open(markerPath, flags, 384);
+  const handle = await fs2.open(stagedPath, flags, 384);
+  let stagedDev = 0;
+  let stagedIno = 0;
   try {
     const before = await handle.stat();
+    stagedDev = before.dev;
+    stagedIno = before.ino;
     if (!before.isFile() || before.nlink !== 1 || before.ino === 0) {
       throw new Error("Worktree session marker has an unsafe identity");
     }
@@ -206,17 +230,43 @@ async function createWorktreeSessionMarkerExclusive(worktreePath, sessionId) {
     await handle.sync();
     const [after, pathStats] = await Promise.all([
       handle.stat(),
-      fs2.lstat(markerPath)
+      fs2.lstat(stagedPath)
     ]);
     if (!after.isFile() || after.nlink !== 1 || after.size > WORKTREE_SESSION_MARKER_MAX_BYTES || after.dev !== before.dev || after.ino !== before.ino || pathStats.dev !== after.dev || pathStats.ino !== after.ino) {
       throw new Error("Worktree session marker identity changed");
     }
-  } finally {
+    await fs2.link(stagedPath, markerPath);
+  } catch (error) {
+    await handle.close().catch(() => {
+    });
+    if (stagedIno !== 0) {
+      try {
+        const current = await fs2.lstat(stagedPath);
+        if (current.dev === stagedDev && current.ino === stagedIno) {
+          await fs2.unlink(stagedPath);
+        }
+      } catch {
+      }
+    }
+    throw error;
+  }
+  try {
+    await fs2.unlink(stagedPath);
     await handle.close();
+  } catch (error) {
+    await handle.close().catch(() => {
+    });
+    throw new WorktreeMarkerCommittedError(sessionId, { cause: error });
   }
   await addWorktreeSessionMarkerExclude(worktreePath);
 }
 __name(createWorktreeSessionMarkerExclusive, "createWorktreeSessionMarkerExclusive");
+function assertValidWorktreeSessionMarkerOwner(sessionId) {
+  if (sessionId.length === 0 || Buffer.byteLength(sessionId, "utf8") > WORKTREE_SESSION_MARKER_MAX_BYTES || sessionId.trim() !== sessionId) {
+    throw new Error("Invalid worktree session marker owner");
+  }
+}
+__name(assertValidWorktreeSessionMarkerOwner, "assertValidWorktreeSessionMarkerOwner");
 async function readWorktreeSessionMarkerStrict(worktreePath) {
   const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
   let handle;
@@ -267,7 +317,13 @@ async function readWorktreeSessionMarkerStrict(worktreePath) {
     if (sessionId.length === 0 || sessionId !== raw || Buffer.byteLength(sessionId, "utf8") > WORKTREE_SESSION_MARKER_MAX_BYTES) {
       return { state: "invalid", reason: "invalid marker owner" };
     }
-    return { state: "valid", sessionId };
+    return {
+      state: "valid",
+      sessionId,
+      uid: process.geteuid === void 0 ? null : after.uid,
+      dev: after.dev,
+      ino: after.ino
+    };
   } catch (error) {
     if (isNodeError(error) && error.code === "ENOENT") {
       return observedMarker ? { state: "invalid", reason: "marker disappeared during read" } : { state: "missing" };
@@ -282,6 +338,122 @@ async function readWorktreeSessionMarkerStrict(worktreePath) {
   }
 }
 __name(readWorktreeSessionMarkerStrict, "readWorktreeSessionMarkerStrict");
+function readWorktreeSessionMarkerStrictSync(worktreePath) {
+  const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  let fd;
+  let observedMarker = false;
+  try {
+    const flags = nodeFs.constants.O_RDONLY | (nodeFs.constants.O_NOFOLLOW ?? 0) | (nodeFs.constants.O_NONBLOCK ?? 0);
+    const before = nodeFs.lstatSync(markerPath);
+    observedMarker = true;
+    if (before.isSymbolicLink() || !before.isFile() || before.nlink !== 1) {
+      return { state: "invalid", reason: "unsafe marker file type" };
+    }
+    if (before.ino === 0 || before.size > WORKTREE_SESSION_MARKER_MAX_BYTES) {
+      return { state: "invalid", reason: "unsafe marker size or identity" };
+    }
+    fd = nodeFs.openSync(markerPath, flags);
+    const opened = nodeFs.fstatSync(fd);
+    if (!opened.isFile() || opened.nlink !== 1 || opened.dev !== before.dev || opened.ino !== before.ino) {
+      return {
+        state: "invalid",
+        reason: "marker identity changed before read"
+      };
+    }
+    const markerBuffer = Buffer.alloc(WORKTREE_SESSION_MARKER_MAX_BYTES + 1);
+    let bytesRead = 0;
+    while (bytesRead < markerBuffer.length) {
+      const chunk = nodeFs.readSync(
+        fd,
+        markerBuffer,
+        bytesRead,
+        markerBuffer.length - bytesRead,
+        bytesRead
+      );
+      if (chunk === 0) break;
+      bytesRead += chunk;
+    }
+    if (bytesRead > WORKTREE_SESSION_MARKER_MAX_BYTES) {
+      return { state: "invalid", reason: "unsafe marker size or identity" };
+    }
+    const raw = markerBuffer.subarray(0, bytesRead).toString("utf8");
+    const after = nodeFs.fstatSync(fd);
+    const pathStats = nodeFs.lstatSync(markerPath);
+    if (!after.isFile() || after.nlink !== 1 || after.size !== bytesRead || after.size > WORKTREE_SESSION_MARKER_MAX_BYTES || after.dev !== opened.dev || after.ino !== opened.ino || !pathStats.isFile() || pathStats.nlink !== 1 || pathStats.dev !== after.dev || pathStats.ino !== after.ino) {
+      return {
+        state: "invalid",
+        reason: "marker identity changed during read"
+      };
+    }
+    const sessionId = raw.trim();
+    if (sessionId.length === 0 || sessionId !== raw || Buffer.byteLength(sessionId, "utf8") > WORKTREE_SESSION_MARKER_MAX_BYTES) {
+      return { state: "invalid", reason: "invalid marker owner" };
+    }
+    return {
+      state: "valid",
+      sessionId,
+      uid: process.geteuid === void 0 ? null : after.uid,
+      dev: after.dev,
+      ino: after.ino
+    };
+  } catch (error) {
+    if (isNodeError(error) && error.code === "ENOENT") {
+      return observedMarker ? { state: "invalid", reason: "marker disappeared during read" } : { state: "missing" };
+    }
+    return {
+      state: "invalid",
+      reason: error instanceof Error ? error.message : String(error)
+    };
+  } finally {
+    if (fd !== void 0) {
+      try {
+        nodeFs.closeSync(fd);
+      } catch {
+      }
+    }
+  }
+}
+__name(readWorktreeSessionMarkerStrictSync, "readWorktreeSessionMarkerStrictSync");
+async function transferWorktreeSessionMarkerOwner(worktreePath, expectedOwner, newOwner) {
+  assertValidWorktreeSessionMarkerOwner(newOwner);
+  if (expectedOwner !== null) {
+    assertValidWorktreeSessionMarkerOwner(expectedOwner);
+    if (expectedOwner === newOwner) {
+      throw new Error("Worktree marker transfer needs a distinct new owner");
+    }
+  }
+  const opening = await readWorktreeSessionMarkerStrict(worktreePath);
+  if (opening.state === "invalid") {
+    throw new Error(`Worktree marker is invalid: ${opening.reason}`);
+  }
+  if (opening.state === "missing") {
+    if (expectedOwner !== null) {
+      throw new Error("Worktree marker owner does not match the expectation");
+    }
+    await createWorktreeSessionMarkerExclusive(worktreePath, newOwner);
+    return;
+  }
+  if (opening.sessionId !== expectedOwner) {
+    throw new Error("Worktree marker owner does not match the expectation");
+  }
+  const euid = process.geteuid?.();
+  if (euid !== void 0 && opening.uid !== null && opening.uid !== euid) {
+    throw new Error("Worktree marker is owned by a different uid");
+  }
+  const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
+  await atomicWriteFile(markerPath, newOwner, {
+    mode: 384,
+    noFollow: true,
+    assertCanCommit: /* @__PURE__ */ __name(() => {
+      const current = readWorktreeSessionMarkerStrictSync(worktreePath);
+      if (current.state !== "valid" || current.sessionId !== opening.sessionId || current.dev !== opening.dev || current.ino !== opening.ino || current.uid !== opening.uid) {
+        throw new Error("Worktree marker changed during ownership transfer");
+      }
+    }, "assertCanCommit")
+  });
+  await addWorktreeSessionMarkerExclude(worktreePath);
+}
+__name(transferWorktreeSessionMarkerOwner, "transferWorktreeSessionMarkerOwner");
 async function readWorktreeSessionMarker(worktreePath) {
   const markerPath = path2.join(worktreePath, WORKTREE_SESSION_FILE);
   try {
@@ -1826,9 +1998,12 @@ export {
   clearRuntimeStatus,
   loadSimpleGit,
   worktreeBranchForSlug,
+  WORKTREE_SESSION_FILE,
   writeWorktreeSessionMarker,
+  WorktreeMarkerCommittedError,
   createWorktreeSessionMarkerExclusive,
   readWorktreeSessionMarkerStrict,
+  transferWorktreeSessionMarkerOwner,
   readWorktreeSessionMarker,
   AGENT_WORKTREE_SLUG_PATTERN,
   generateAgentWorktreeSlug,

package/chunks/{chunk-EJNYBDYC.js → chunk-HNLMYDQE.js}

@@ -8,7 +8,7 @@ import {
   isQuotaExhaustedError,
   isQwenQuotaExceededError,
   isRateLimitError
-} from "./chunk-W4LL5RZO.js";
+} from "./chunk-4ALNJDHL.js";
 import {
   createDebugLogger,
   getErrorStatus

package/chunks/{chunk-JOPC3FND.js → chunk-HUX2DOTF.js}

@@ -2,26 +2,26 @@
 "use strict";
 import {
   t
-} from "./chunk-MUZCSTOO.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   computeThresholds,
   estimateContextTextTokens,
   formatContextFileDisplayPath,
   getMainSessionBaseSystemPrompt
-} from "./chunk-I72PHOKL.js";
+} from "./chunk-PDUMGZ2P.js";
 import {
   DiscoveredMCPTool,
   uiTelemetryService
-} from "./chunk-P5LDR7FI.js";
+} from "./chunk-6QV7Z74P.js";
 import {
   DEFAULT_TOKEN_LIMIT
 } from "./chunk-FPGTNKCP.js";
 import {
   buildSkillLlmContent
-} from "./chunk-NGX4NUNP.js";
+} from "./chunk-O2FEO2CB.js";
 import {
   ToolNames
-} from "./chunk-RPBMP6BN.js";
+} from "./chunk-MWIO7MF6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-GCFZ2LAX.js → chunk-HZ2HUXX7.js}

@@ -3,10 +3,10 @@
 import {
   SERVE_CONTROL_EXT_METHODS,
   STATUS_SCHEMA_VERSION
-} from "./chunk-KPXRFTT7.js";
+} from "./chunk-FETY36NQ.js";
 import {
   WorkspaceDrainingError
-} from "./chunk-F47DITLZ.js";
+} from "./chunk-FAWTMDX7.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-CWNC7M73.js → chunk-IKG2YVRZ.js}

@@ -3,11 +3,11 @@
 import {
   TURN_INTERRUPTION_HISTORY_TAIL_COUNT,
   detectTurnInterruption
-} from "./chunk-UEZOXZNI.js";
+} from "./chunk-ZU2T5JIS.js";
 import {
   SessionService,
   buildApiHistoryFromConversation
-} from "./chunk-I72PHOKL.js";
+} from "./chunk-PDUMGZ2P.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-L4R7BCVV.js → chunk-J3TJH52D.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   CHANNEL_STARTUP_PROFILE_VERSION
-} from "./chunk-WEXA2DNG.js";
+} from "./chunk-PSPAM24S.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QMFOYPGV.js → chunk-J3VZF2AL.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   hasControlCharacter
-} from "./chunk-LDS57224.js";
+} from "./chunk-OWCFKIFQ.js";
 import {
   BaseDeclarativeTool,
   BaseToolInvocation,
   ToolDisplayNames,
   ToolNames
-} from "./chunk-RPBMP6BN.js";
+} from "./chunk-MWIO7MF6.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-ZJ2LM2SI.js → chunk-JGDRB4FP.js}

@@ -1,8 +1,12 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  REASONING_EFFORT_TIERS
-} from "./chunk-2LD5U7Q3.js";
+  ACP_ROUTE_ID_PREFIX
+} from "./chunk-ARYNBBBM.js";
+import {
+  REASONING_EFFORT_TIERS,
+  parseModelReasoningCapabilities
+} from "./chunk-6YEOCHSE.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -14,19 +18,34 @@ import {
 init_esbuild_shims();
 var MODEL_CONFIGURATIONS = {
   "qwen3.5-plus": {
-    reasoning: { thinking: true, toggleOnly: true }
+    reasoning: {
+      thinking: true,
+      toggleOnly: true
+    }
   },
   "qwen3.6-plus": {
-    reasoning: { thinking: true, toggleOnly: true }
+    reasoning: {
+      thinking: true,
+      toggleOnly: true
+    }
   },
   "qwen3.6-flash": {
-    reasoning: { thinking: true, toggleOnly: true }
+    reasoning: {
+      thinking: true,
+      toggleOnly: true
+    }
   },
   "qwen3.7-plus": {
-    reasoning: { thinking: true, toggleOnly: true }
+    reasoning: {
+      thinking: true,
+      toggleOnly: true
+    }
   },
   "qwen3.7-max": {
-    reasoning: { thinking: true, toggleOnly: true }
+    reasoning: {
+      thinking: true,
+      toggleOnly: true
+    }
   },
   "qwen3.8-max": {
     reasoning: {
@@ -47,18 +66,45 @@ var REASONING_EFFORT_NAMES = {
   xhigh: "Extra high",
   max: "Max"
 };
-function resolvePersistedReasoningConfigState(modelId, value, thinkingMandatory = false) {
+function resolvePersistedReasoningConfigState(modelId, value, thinkingMandatory = false, reasoning) {
   const selection = parseReasoningSelection(value);
-  if (!selection || selection === REASONING_EFFORT_DEFAULT || !isReasoningSelectionSupported(modelId, selection, thinkingMandatory)) {
+  if (!selection || selection === REASONING_EFFORT_DEFAULT || !isReasoningSelectionSupported(
+    modelId,
+    selection,
+    thinkingMandatory,
+    reasoning
+  )) {
     return { thinkingMandatory };
   }
   return selection === REASONING_EFFORT_NONE ? { enabled: false, thinkingMandatory } : { enabled: true, effort: selection, thinkingMandatory };
 }
 __name(resolvePersistedReasoningConfigState, "resolvePersistedReasoningConfigState");
-function getModelConfiguration(modelId) {
-  return modelId ? MODEL_CONFIGURATIONS[modelId] : void 0;
+function getModelConfiguration(modelId, reasoning) {
+  const configured = parseModelReasoningCapabilities(reasoning);
+  return configured ? { reasoning: configured } : modelId ? MODEL_CONFIGURATIONS[modelId] : void 0;
 }
 __name(getModelConfiguration, "getModelConfiguration");
+function getConfiguredModelReasoning(config, modelId = config.getModel?.(), fallbackToManifest = true) {
+  if (config.getActiveRuntimeModelSnapshot?.() || config.getModel?.().startsWith(ACP_ROUTE_ID_PREFIX)) {
+    return void 0;
+  }
+  const generation = config.getContentGeneratorConfig?.();
+  const authType = generation?.authType ?? config.getAuthType?.();
+  const baseUrl = generation?.baseUrl ?? config.getCurrentModelRegistryBaseUrl?.() ?? void 0;
+  const configured = authType ? config.getResolvedModelConfig?.(authType, modelId, baseUrl) : void 0;
+  const reasoning = parseModelReasoningCapabilities(
+    configured?.capabilities?.reasoning
+  );
+  return reasoning ?? (fallbackToManifest ? getModelConfiguration(modelId)?.reasoning : void 0);
+}
+__name(getConfiguredModelReasoning, "getConfiguredModelReasoning");
+function getReasoningEffortsForConfig(config) {
+  const modelId = config.getModel?.();
+  const reasoning = getConfiguredModelReasoning(config, modelId, false);
+  if (reasoning) return reasoning.toggleOnly ? [] : reasoning.efforts;
+  return REASONING_EFFORT_TIERS;
+}
+__name(getReasoningEffortsForConfig, "getReasoningEffortsForConfig");
 function parseReasoningSelection(value) {
   if (value === REASONING_EFFORT_NONE || value === REASONING_EFFORT_DEFAULT) {
     return value;
@@ -66,17 +112,22 @@ function parseReasoningSelection(value) {
   return REASONING_EFFORT_TIERS.find((tier) => tier === value);
 }
 __name(parseReasoningSelection, "parseReasoningSelection");
-function isReasoningSelectionSupported(modelId, selection, thinkingMandatory = false) {
+function isReasoningSelectionSupported(modelId, selection, thinkingMandatory = false, configuredReasoning) {
   if (!modelId) return false;
-  const reasoning = getModelConfiguration(modelId)?.reasoning;
+  const reasoning = getModelConfiguration(
+    modelId,
+    configuredReasoning
+  )?.reasoning;
   if (!reasoning?.thinking) {
     const normalized = modelId.toLowerCase();
     if (normalized.startsWith("qwen") || normalized === "coder-model")
       return false;
   }
   if (selection === REASONING_EFFORT_DEFAULT) return true;
-  if (selection === REASONING_EFFORT_NONE) return !thinkingMandatory;
-  return reasoning?.thinking ? !reasoning.toggleOnly && reasoning.efforts.includes(selection) : REASONING_EFFORT_TIERS.includes(selection);
+  if (selection === REASONING_EFFORT_NONE) {
+    return reasoning?.canDisable !== false && !thinkingMandatory;
+  }
+  return reasoning?.thinking ? !reasoning.toggleOnly && reasoning.efforts?.includes(selection) === true : REASONING_EFFORT_TIERS.includes(selection);
 }
 __name(isReasoningSelectionSupported, "isReasoningSelectionSupported");
 function clearReasoningRequestOverrides(generation) {
@@ -124,11 +175,14 @@ function applyReasoningSelection(config, selection, defaultReasoning) {
   if (rebuildable !== live) apply(rebuildable);
 }
 __name(applyReasoningSelection, "applyReasoningSelection");
-function buildModelReasoningConfigOption(modelId, state = {}) {
-  const reasoning = getModelConfiguration(modelId)?.reasoning;
+function buildModelReasoningConfigOption(modelId, state = {}, configuredReasoning) {
+  const reasoning = getModelConfiguration(
+    modelId,
+    configuredReasoning
+  )?.reasoning;
   if (!reasoning?.thinking) return void 0;
-  const thinkingMandatory = state.thinkingMandatory === true;
-  const currentValue = state.enabled === false && !thinkingMandatory ? REASONING_EFFORT_NONE : reasoning.toggleOnly ? REASONING_EFFORT_DEFAULT : reasoning.efforts.find((effort) => effort === state.effort) ?? reasoning.defaultEffort;
+  const canDisable = reasoning.canDisable !== false && state.thinkingMandatory !== true;
+  const currentValue = state.enabled === false && canDisable ? REASONING_EFFORT_NONE : reasoning.toggleOnly ? REASONING_EFFORT_DEFAULT : reasoning.efforts?.find((effort) => effort === state.effort) ?? reasoning.defaultEffort ?? REASONING_EFFORT_DEFAULT;
   return {
     id: "reasoning_effort",
     name: "Reasoning effort",
@@ -137,41 +191,57 @@ function buildModelReasoningConfigOption(modelId, state = {}) {
     type: "select",
     currentValue,
     options: [
-      ...thinkingMandatory ? [] : [
+      ...canDisable ? [
         {
           value: REASONING_EFFORT_NONE,
           name: "Thinking off",
           description: "Disable thinking for this session"
         }
-      ],
+      ] : [],
       ...reasoning.toggleOnly ? [
         {
           value: REASONING_EFFORT_DEFAULT,
           name: "Thinking on",
           description: "Use the model or provider thinking default"
         }
-      ] : reasoning.efforts.map((effort) => ({
-        value: effort,
-        name: REASONING_EFFORT_NAMES[effort],
-        description: "Apply this effort to the next request"
-      }))
+      ] : [
+        ...reasoning.defaultEffort ? [] : [
+          {
+            value: REASONING_EFFORT_DEFAULT,
+            name: "Default",
+            description: "Use the model or provider default"
+          }
+        ],
+        ...reasoning.efforts.map((effort) => ({
+          value: effort,
+          name: REASONING_EFFORT_NAMES[effort],
+          description: "Apply this effort to the next request"
+        }))
+      ]
     ],
     _meta: {
       "qwenCode/reasoning": reasoning.toggleOnly ? {
         toggleOnly: true,
-        ...thinkingMandatory ? { thinkingMandatory: true } : {}
+        ...canDisable ? {} : { thinkingMandatory: true }
       } : {
-        defaultEffort: reasoning.defaultEffort,
-        ...thinkingMandatory ? { thinkingMandatory: true } : {}
+        ...reasoning.defaultEffort ? { defaultEffort: reasoning.defaultEffort } : {},
+        ...canDisable ? {} : { thinkingMandatory: true }
       }
     }
   };
 }
 __name(buildModelReasoningConfigOption, "buildModelReasoningConfigOption");
-function buildModelReasoningConfigPreview(modelId, state = {}) {
-  const reasoning = getModelConfiguration(modelId)?.reasoning;
+function buildModelReasoningConfigPreview(modelId, state = {}, configuredReasoning) {
+  const reasoning = getModelConfiguration(
+    modelId,
+    configuredReasoning
+  )?.reasoning;
   if (!reasoning?.thinking) return void 0;
-  const option = buildModelReasoningConfigOption(modelId, state);
+  const option = buildModelReasoningConfigOption(
+    modelId,
+    state,
+    configuredReasoning
+  );
   return option ? [option] : void 0;
 }
 __name(buildModelReasoningConfigPreview, "buildModelReasoningConfigPreview");
@@ -183,7 +253,8 @@ export {
   REASONING_SELECTION_PERSISTED_META_KEY,
   REASONING_EFFORT_NAMES,
   resolvePersistedReasoningConfigState,
-  getModelConfiguration,
+  getConfiguredModelReasoning,
+  getReasoningEffortsForConfig,
   parseReasoningSelection,
   isReasoningSelectionSupported,
   clearReasoningRequestOverrides,

package/chunks/{chunk-LMJQSPWB.js → chunk-KA5HR3G2.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   MissingCliEntryError
-} from "./chunk-KPXRFTT7.js";
+} from "./chunk-FETY36NQ.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";

package/chunks/{chunk-G34YLYCS.js → chunk-L7V52QEZ.js}

@@ -2,22 +2,22 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-ZAZ3NFL6.js";
+} from "./chunk-DXQ6Z7AH.js";
 import {
   CUSTOM_SANDBOX_IMAGE_ENV_VAR,
   HOST_UPDATE_RELAUNCH_ENV_VAR,
   SKIP_UPDATE_CHECK_ENV_VAR,
   requestUpdateOnExit
-} from "./chunk-4VZCORNT.js";
+} from "./chunk-RXT4QBDX.js";
 import {
   loadUndici
 } from "./chunk-TXASDT2M.js";
 import {
   getAllProviderBaseUrls
-} from "./chunk-UEZOXZNI.js";
+} from "./chunk-ZU2T5JIS.js";
 import {
   IdeClient
-} from "./chunk-I72PHOKL.js";
+} from "./chunk-PDUMGZ2P.js";
 import {
   detectRuntime,
   getOrCreateSharedDispatcher,
@@ -233,11 +233,11 @@ function startPostRenderPrefetches(config, settings, options = {}) {
         { updateEventEmitter },
         { t }
       ] = await Promise.all([
-        import("./updateCheck-W6UZFURI.js"),
-        import("./handleAutoUpdate-D56FMDTW.js"),
-        import("./installationInfo-542MGC4S.js"),
+        import("./updateCheck-WAVFLWNG.js"),
+        import("./handleAutoUpdate-2FUNJO3B.js"),
+        import("./installationInfo-232RA2OK.js"),
         import("./updateEventEmitter-5MKC7BLQ.js"),
-        import("./i18n-BKE5WO6T.js")
+        import("./i18n-FDIA6KFI.js")
       ]);
       const updateCheckSkippedMessage = /* @__PURE__ */ __name((error) => t("Update check skipped ({{reason}}) \u2014 run /update to retry.", {
         reason: describeUpdateCheckFailure(error)
@@ -310,7 +310,7 @@ ${t(
         state: "connecting"
       });
       try {
-        const { connectIdeForStartup } = await import("./initializer-MS4SGEHF.js");
+        const { connectIdeForStartup } = await import("./initializer-4MJTJOTW.js");
         await withTimeout(
           connectIdeForStartup(config),
           "ide_connect",
@@ -334,7 +334,7 @@ ${t(
   }
   if (config.isInteractive()) {
     runDeferredTask("background_housekeeping", async () => {
-      const { startBackgroundHousekeeping } = await import("./scheduler-DQI6KV7T.js");
+      const { startBackgroundHousekeeping } = await import("./scheduler-J44M72VM.js");
       startBackgroundHousekeeping(config, settings);
     });
   }