@qwen-code/qwen-code 0.21.5 → 0.21.6-nightly.20260806.cb3dc107f

package/chunks/{chunk-4LLUH3A7.js → chunk-HU5TUALO.js}

@@ -6,6 +6,10 @@ import {
   DEFAULT_MAX_RETRIES,
   resolveRequestTimeout
 } from "./chunk-GLNBDYUX.js";
+import {
+  isQwenFamilyWireModel,
+  isTieredEffortWireModel
+} from "./chunk-WOJZWRAZ.js";
 import {
   defaultOutputCeiling,
   hasExplicitOutputLimit,
@@ -7158,10 +7162,11 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       if (hasQwenEffortConfig && "reasoning" in visionResult) {
         delete visionResult["reasoning"];
       }
-      return {
-        ...visionResult,
-        ...extraBody ? extraBody : {}
-      };
+      return this.mergeExtraBodyAndResolveKnobs(
+        visionResult,
+        extraBody,
+        request.model
+      );
     }
     const dashscopeExtras = {
       preserve_thinking: true,
@@ -7178,25 +7183,107 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     if (hasQwenEffortConfig && "reasoning" in result) {
       delete result["reasoning"];
     }
-    return {
+    return this.mergeExtraBodyAndResolveKnobs(result, extraBody, request.model);
+  }
+  /**
+   * Shared tail for the vision and text branches: merge user extra_body
+   * last, then resolve thinking-knob conflicts against the wire model.
+   */
+  mergeExtraBodyAndResolveKnobs(result, extraBody, model) {
+    const merged = {
       ...result,
       ...extraBody ? extraBody : {}
     };
+    this.dropConflictingThinkingKnobs(model, merged);
+    return merged;
+  }
+  resolveWireModel(model) {
+    return (model ?? this.contentGeneratorConfig.model ?? "").toLowerCase();
   }
+  /**
+   * Translate the unified reasoning effort into the wire shape the model
+   * accepts. The qwen3.8-max family takes the tiered `reasoning_effort`
+   * directly; older qwen hybrid models expose only the on/off
+   * `enable_thinking` switch, so the effort ladder collapses to on/off
+   * there. Gated to qwen-family wire models (mirroring the pipeline's
+   * disable gate) so the qwen-specific fields never leak to a non-qwen
+   * model sharing the DashScope endpoint.
+   */
   buildQwenEffortConfig(model) {
     const reasoning = this.contentGeneratorConfig.reasoning;
     if (!reasoning || reasoning.effort === void 0) {
       return {};
     }
-    const wireModel = (model ?? this.contentGeneratorConfig.model ?? "").toLowerCase();
-    if (wireModel === "qwen3.8-max" || wireModel === "qwen3.8-max-preview") {
+    const wireModel = this.resolveWireModel(model);
+    if (isTieredEffortWireModel(wireModel)) {
       return { reasoning_effort: reasoning.effort };
     }
-    if (wireModel.startsWith("qwen") || wireModel === "coder-model") {
+    if (isQwenFamilyWireModel(wireModel)) {
       return { enable_thinking: true };
     }
     return {};
   }
+  /**
+   * Resolve thinking knobs that conflict with a shipping `reasoning_effort`.
+   * Preset extra_body injects `enable_thinking` for models declared with
+   * enableThinking (provider-config.ts), and user extra_body merges last.
+   * Only the qwen3.8-max family reads `reasoning_effort` itself — there the
+   * tier ships alone: an `enable_thinking: true` alongside it is a second
+   * competing knob (the shape the nested-`reasoning` strip in buildRequest
+   * exists to prevent), and DashScope rejects `reasoning_effort` combined
+   * with `thinking_budget`. An explicit `enable_thinking: false` is the
+   * documented extra_body escape hatch winning over the config tier, so it
+   * is honoured as the family's canonical disable (`reasoning_effort:
+   * 'none'`, preserved by the pipeline's disable strip) rather than
+   * silently deleted. Older qwen hybrids read `enable_thinking` /
+   * `thinking_budget`, not `reasoning_effort`, so when an opaque
+   * reasoning_effort override conflicts with a meaningful thinking_budget
+   * the inert field goes and the knobs the model reads survive. Non-qwen
+   * models treat `reasoning_effort` as an opaque sampling override and
+   * keep every knob.
+   */
+  dropConflictingThinkingKnobs(model, merged) {
+    const effort = merged["reasoning_effort"];
+    if (typeof effort !== "string" || effort === "none") {
+      return;
+    }
+    const wireModel = this.resolveWireModel(model);
+    if (!isQwenFamilyWireModel(wireModel)) {
+      return;
+    }
+    const dropped = [];
+    if (isTieredEffortWireModel(wireModel)) {
+      if ("enable_thinking" in merged) {
+        if (merged["enable_thinking"] === false) {
+          merged["reasoning_effort"] = "none";
+        }
+        dropped.push("enable_thinking");
+      }
+      if ("thinking_budget" in merged) {
+        dropped.push("thinking_budget");
+      }
+    } else if ("thinking_budget" in merged) {
+      dropped.push("reasoning_effort");
+    }
+    if (dropped.length === 0) {
+      return;
+    }
+    for (const key of dropped) {
+      delete merged[key];
+    }
+    if (!this.conflictingKnobDropWarned) {
+      this.conflictingKnobDropWarned = true;
+      debugLogger.warn(
+        "DashScope: dropped extra_body thinking knobs that conflict with reasoning_effort",
+        {
+          model: wireModel,
+          reasoningEffort: merged["reasoning_effort"],
+          dropped
+        }
+      );
+    }
+  }
+  conflictingKnobDropWarned = false;
   buildMetadata(userPromptId) {
     const channel = this.cliConfig.getChannel?.();
     return {

package/chunks/{chunk-N3RERU5N.js → chunk-I2O7DAYN.js}

@@ -2,14 +2,14 @@
 "use strict";
 import {
   functionResponsePartsToString
-} from "./chunk-IWYXZAGT.js";
+} from "./chunk-RE7NVPE7.js";
 import {
   parseAndFormatApiError
-} from "./chunk-YLL3SC5S.js";
+} from "./chunk-NSESTZWP.js";
 import {
   formatVisionBridgeNoticeDisplay,
   isVisionBridgeNoticeDisplay
-} from "./chunk-ZPGMDT4S.js";
+} from "./chunk-LLM2DCGI.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";