@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.2-nightly.20260909.2e212144d3

package/chunks/{chunk-FDOGGKAA.js → chunk-GSFV5RQW.js}

@@ -47,6 +47,7 @@ var KNOWN_RECORD_SUBTYPES = /* @__PURE__ */ new Set([
   "agent_bootstrap",
   "agent_launch_prompt",
   "agent_retry",
+  "agent_session_ready",
   "file_history_snapshot",
   "session_source",
   "session_model",
@@ -235,6 +236,7 @@ function validateTranscriptRecord(value, recordIndex) {
       uuid,
       parentUuid,
       sessionId,
+      daemonPromptId: typeof value["daemonPromptId"] === "string" && value["daemonPromptId"].trim().length > 0 ? value["daemonPromptId"] : void 0,
       type,
       ...typeof subtype === "string" ? { subtype } : { subtype: void 0 },
       ...typeof timestamp === "string" && Number.isFinite(new Date(timestamp).getTime()) ? { timestamp } : { timestamp: void 0 },

package/chunks/{chunk-XBVNNDPK.js → chunk-GSYD7MYP.js}

@@ -1,8 +1,9 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  normalize
-} from "./chunk-FPGTNKCP.js";
+  normalize,
+  parseModelReasoningCapabilities
+} from "./chunk-F3M6P6IQ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -110,10 +111,14 @@ function isQwenFamilyWireModel(model) {
   return normalized.startsWith("qwen") || normalized === "coder-model";
 }
 __name(isQwenFamilyWireModel, "isQwenFamilyWireModel");
-function isTieredEffortWireModel(model) {
+function isTieredEffortWireModel(model, configuredReasoning) {
   if (!model) {
     return false;
   }
+  const reasoning = parseModelReasoningCapabilities(configuredReasoning);
+  if (reasoning) {
+    return isQwenFamilyWireModel(model) && !reasoning.toggleOnly && reasoning.disableField === "reasoning_effort";
+  }
   return model.toLowerCase().startsWith("qwen3.8-max");
 }
 __name(isTieredEffortWireModel, "isTieredEffortWireModel");

package/chunks/{chunk-ERMAXPXA.js → chunk-HIXUUCGY.js}

@@ -8,6 +8,7 @@ import {
   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-3K456UJF.js → chunk-HSO6D4KX.js}

@@ -4,23 +4,26 @@ import {
   DASHSCOPE_PROXY_BASE_URL,
   DEFAULT_DASHSCOPE_BASE_URL,
   DEFAULT_MAX_RETRIES,
-  REASONING_EFFORT_TIERS,
-  clampReasoningEffort,
   resolveRequestTimeout
-} from "./chunk-2LD5U7Q3.js";
+} from "./chunk-AXMWHKXA.js";
 import {
   buildSessionAwareFetch
-} from "./chunk-3UMWOKJC.js";
+} from "./chunk-NOO4QFXM.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
-} from "./chunk-XBVNNDPK.js";
+} from "./chunk-GSYD7MYP.js";
 import {
+  REASONING_EFFORT_TIERS,
+  clampReasoningEffort,
   defaultOutputCeiling,
+  getGptReasoningCapabilities,
   hasExplicitOutputLimit,
+  isReasoningEffortPlaceholder,
+  parseModelReasoningCapabilities,
   parsePositiveIntegerEnvValue,
   tokenLimit
-} from "./chunk-FPGTNKCP.js";
+} from "./chunk-F3M6P6IQ.js";
 import {
   buildRuntimeFetchOptions
 } from "./chunk-4HOEU2OR.js";
@@ -6886,6 +6889,22 @@ init_esbuild_shims();
 
 // packages/core/src/core/openaiContentGenerator/provider/default.ts
 init_esbuild_shims();
+
+// packages/core/src/core/openaiContentGenerator/provider/openrouter.ts
+init_esbuild_shims();
+function isOpenRouterHostname(contentGeneratorConfig) {
+  const baseUrl = contentGeneratorConfig.baseUrl ?? "";
+  if (!baseUrl) return false;
+  try {
+    const hostname = new URL(baseUrl).hostname.toLowerCase();
+    return hostname === "openrouter.ai" || hostname.endsWith(".openrouter.ai");
+  } catch {
+    return false;
+  }
+}
+__name(isOpenRouterHostname, "isOpenRouterHostname");
+
+// packages/core/src/core/openaiContentGenerator/provider/default.ts
 var debugLogger = createDebugLogger("DefaultOpenAICompatibleProvider");
 var OPENAI_COMPATIBLE_EFFORTS = [
   "low",
@@ -6955,7 +6974,11 @@ var DefaultOpenAICompatibleProvider = class {
       maxRetries,
       defaultHeaders,
       ...runtimeOptions || {},
-      fetch: buildSessionAwareFetch(runtimeOptions?.fetch, this.cliConfig)
+      fetch: buildSessionAwareFetch(
+        runtimeOptions?.fetch,
+        this.cliConfig,
+        this.contentGeneratorConfig.customHeaders
+      )
     });
   }
   /**
@@ -6967,8 +6990,14 @@ var DefaultOpenAICompatibleProvider = class {
    * clamp calls it through `this`, so a subclass answer applies even on the
    * `super.buildRequest` path.
    */
-  supportedReasoningEffortsFor(_model) {
-    return OPENAI_COMPATIBLE_EFFORTS;
+  supportedReasoningEffortsFor(model) {
+    const gpt = getGptReasoningCapabilities(model);
+    if (!gpt) return OPENAI_COMPATIBLE_EFFORTS;
+    const { authType, baseUrl } = this.contentGeneratorConfig;
+    const configured = authType && model ? parseModelReasoningCapabilities(
+      this.cliConfig.getResolvedModelConfig?.(authType, model, baseUrl)?.capabilities.reasoning
+    ) : void 0;
+    return configured && !configured.toggleOnly ? configured.efforts : gpt.efforts;
   }
   /**
    * Cap the pipeline-injected `reasoning.effort` at what this endpoint accepts.
@@ -6977,8 +7006,8 @@ var DefaultOpenAICompatibleProvider = class {
    * session too.
    *
    * Only the pipeline-injected tier is capped. A `reasoning` object the user
-   * put in `samplingParams` ships verbatim (the pipeline hands those keys
-   * straight to the wire and skips the injection entirely), and `extra_body`
+   * put in `samplingParams` ships verbatim. Unrelated GPT sampling options
+   * still receive the configured effort and need clamping. `extra_body`
    * merges after this, so both explicit overrides survive unchanged.
    */
   clampConfiguredReasoningEffort(request) {
@@ -7017,11 +7046,25 @@ var DefaultOpenAICompatibleProvider = class {
       this.applyOutputTokenLimit(request)
     );
     const messages = isQwen3Model(request.model) ? requestWithTokenLimits.messages.map(mirrorReasoningContentToReasoning) : requestWithTokenLimits.messages;
-    return {
+    const result = {
       ...requestWithTokenLimits,
       messages,
       ...extraBody ? extraBody : {}
     };
+    this.flattenGptReasoningEffort(result);
+    return result;
+  }
+  flattenGptReasoningEffort(body) {
+    if (!getGptReasoningCapabilities(body["model"]) || isOpenRouterHostname(this.contentGeneratorConfig) || this.contentGeneratorConfig.samplingParams?.["reasoning"] !== void 0 || this.contentGeneratorConfig.extra_body?.["reasoning"] !== void 0)
+      return;
+    const reasoning = body["reasoning"];
+    if (typeof reasoning?.effort !== "string" || !reasoning.effort) return;
+    if (isReasoningEffortPlaceholder(body["reasoning_effort"])) {
+      body["reasoning_effort"] = reasoning.effort;
+    }
+    const { effort: _drop, ...rest } = reasoning;
+    if (Object.keys(rest).length > 0) body["reasoning"] = rest;
+    else delete body["reasoning"];
   }
   getDefaultGenerationConfig() {
     return {};
@@ -7105,8 +7148,8 @@ var DASHSCOPE_TIERED_EFFORTS = [
   "high",
   "xhigh"
 ];
-function selectDashScopeThinkingKnob(model, extraBody, samplingParams, reasoningEffort) {
-  if (!isTieredEffortWireModel((model ?? "").toLowerCase())) {
+function selectDashScopeThinkingKnob(model, extraBody, samplingParams, reasoningEffort, tieredModel = isTieredEffortWireModel(model)) {
+  if (!tieredModel) {
     return void 0;
   }
   const selectFromLayer = /* @__PURE__ */ __name((source, layer) => {
@@ -7270,7 +7313,11 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       maxRetries,
       defaultHeaders,
       ...runtimeOptions || {},
-      fetch: buildSessionAwareFetch(runtimeOptions?.fetch, this.cliConfig)
+      fetch: buildSessionAwareFetch(
+        runtimeOptions?.fetch,
+        this.cliConfig,
+        this.contentGeneratorConfig.customHeaders
+      )
     });
   }
   /**
@@ -7302,9 +7349,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       tools = updatedTools;
     }
     const requestWithTokenLimits = this.applyOutputTokenLimit(request);
-    const isTieredQwenModel = isTieredEffortWireModel(
-      this.resolveWireModel(request.model)
-    );
+    const isTieredQwenModel = this.isTieredEffortModel(request.model);
     const extraBody = isTieredQwenModel ? withoutNullishThinkingKnobs(this.contentGeneratorConfig.extra_body) : this.contentGeneratorConfig.extra_body;
     const qwenEffortConfig = this.buildQwenEffortConfig(request.model);
     const rawRequestParams = requestWithTokenLimits;
@@ -7317,7 +7362,8 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       this.resolveWireModel(request.model),
       extraBody,
       requestParams,
-      qwenEffortConfig["reasoning_effort"]
+      qwenEffortConfig["reasoning_effort"],
+      isTieredQwenModel
     ) : void 0;
     if (this.isVisionModel(request.model)) {
       const dashscopeExtras2 = {
@@ -7397,8 +7443,21 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       dropped.add(key);
     }
     this.warnConflictingKnobDrop(model, reasoningEffort, [...dropped]);
+    this.flattenGptReasoningEffort(merged);
     return merged;
   }
+  getConfiguredReasoning(model) {
+    const { authType, baseUrl } = this.contentGeneratorConfig;
+    const wireModel = model ?? this.contentGeneratorConfig.model;
+    const reasoning = authType ? this.cliConfig.getResolvedModelConfig?.(authType, wireModel, baseUrl)?.capabilities.reasoning : void 0;
+    return parseModelReasoningCapabilities(reasoning);
+  }
+  isTieredEffortModel(model) {
+    return isTieredEffortWireModel(
+      model ?? this.contentGeneratorConfig.model,
+      this.getConfiguredReasoning(model)
+    );
+  }
   resolveWireModel(model) {
     return (model ?? this.contentGeneratorConfig.model ?? "").toLowerCase();
   }
@@ -7417,7 +7476,11 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       return {};
     }
     const wireModel = this.resolveWireModel(model);
-    if (isTieredEffortWireModel(wireModel)) {
+    if (this.isTieredEffortModel(model)) {
+      const configured = this.getConfiguredReasoning(model);
+      if (configured && !configured.toggleOnly) {
+        return configured.efforts.includes(reasoning.effort) ? { reasoning_effort: reasoning.effort } : {};
+      }
       return { reasoning_effort: this.clampTieredEffort(reasoning.effort) };
     }
     if (isQwenFamilyWireModel(wireModel)) {
@@ -7426,13 +7489,9 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     return {};
   }
   /**
-   * Cap a configured tier at what the qwen3.8-max family actually accepts.
-   * This family does not take `max`, and the rejection is a 400 on every
-   * subsequent request rather than a one-off, so the tier is clamped to the
-   * strongest supported tier and reported once. Only the
-   * configured `reasoning.effort` passes through here: an explicit
-   * `extra_body` / `samplingParams` `reasoning_effort` is a documented
-   * verbatim override and is merged after this, so it still ships unchanged.
+   * Preserve the legacy clamp for a route without an explicit capability.
+   * Only the unified reasoning.effort preference reaches this fallback;
+   * extra_body and samplingParams remain verbatim provider overrides.
    */
   clampTieredEffort(effort) {
     const clamped = clampReasoningEffort(effort, DASHSCOPE_TIERED_EFFORTS);
@@ -7473,7 +7532,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     if (!isQwenFamilyWireModel(wireModel)) {
       return [];
     }
-    const isTieredEffortModel = isTieredEffortWireModel(wireModel);
+    const isTieredEffortModel = this.isTieredEffortModel(model);
     if (isTieredEffortModel && selectedThinkingKnob?.field === "enable_thinking" && selectedThinkingKnob.value === false) {
       merged["reasoning_effort"] = "none";
       const dropped = ["enable_thinking"];
@@ -7711,8 +7770,14 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
 
 export {
   OpenAI,
+  isOpenRouterHostname,
   DefaultOpenAICompatibleProvider,
   selectDashScopeThinkingKnob,
   DASHSCOPE_REGIONAL_HOSTS,
   DashScopeOpenAICompatibleProvider
 };
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-ANVC5CSK.js → chunk-HUJJFSMO.js}

@@ -2,22 +2,22 @@
 "use strict";
 import {
   appEvents
-} from "./chunk-P5Z7VD23.js";
+} from "./chunk-3O77M472.js";
 import {
   CUSTOM_SANDBOX_IMAGE_ENV_VAR,
   HOST_UPDATE_RELAUNCH_ENV_VAR,
   SKIP_UPDATE_CHECK_ENV_VAR,
   requestUpdateOnExit
-} from "./chunk-22QOQKG4.js";
+} from "./chunk-5WBA3DEF.js";
 import {
   loadUndici
 } from "./chunk-TXASDT2M.js";
 import {
   getAllProviderBaseUrls
-} from "./chunk-TXAEXF2B.js";
+} from "./chunk-PLEBBGHL.js";
 import {
   IdeClient
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-BDAVT6K2.js";
 import {
   detectRuntime,
   getOrCreateSharedDispatcher,
@@ -233,11 +233,11 @@ function startPostRenderPrefetches(config, settings, options = {}) {
         { updateEventEmitter },
         { t }
       ] = await Promise.all([
-        import("./updateCheck-3MYFMM35.js"),
-        import("./handleAutoUpdate-RUPZZTSG.js"),
-        import("./installationInfo-IRPQEYRF.js"),
+        import("./updateCheck-ARTHAJT2.js"),
+        import("./handleAutoUpdate-JDZHHZKK.js"),
+        import("./installationInfo-QEQEPB3G.js"),
         import("./updateEventEmitter-5MKC7BLQ.js"),
-        import("./i18n-SF5MPWEB.js")
+        import("./i18n-LA4D5IXM.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-CK4WPYZG.js");
+        const { connectIdeForStartup } = await import("./initializer-SHPTSWUZ.js");
         await withTimeout(
           connectIdeForStartup(config),
           "ide_connect",
@@ -334,7 +334,7 @@ ${t(
   }
   if (config.isInteractive()) {
     runDeferredTask("background_housekeeping", async () => {
-      const { startBackgroundHousekeeping } = await import("./scheduler-EXU5HMVK.js");
+      const { startBackgroundHousekeeping } = await import("./scheduler-ERMW7Q7B.js");
       startBackgroundHousekeeping(config, settings);
     });
   }

package/chunks/{chunk-C4NXRR7T.js → chunk-HW4MRP4V.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   useKeypress
-} from "./chunk-AWDF462I.js";
+} from "./chunk-VR6Y23FW.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   t
-} from "./chunk-LD53HMPV.js";
+} from "./chunk-CRZBDVP2.js";
 import {
   APPROVAL_MODES
 } from "./chunk-JX6XHPTX.js";