@qwen-code/qwen-code 0.21.10 → 0.21.11

package/chunks/{channel-worker-supervisor-IVSDIMI4.js → channel-worker-supervisor-YDAGW2RP.js}

@@ -4,19 +4,20 @@ import {
   ChannelWorkerStartupError,
   ChannelWorkerStopError,
   createChannelWorkerSupervisor
-} from "./chunk-MFDYOYZZ.js";
+} from "./chunk-4MHDNGAV.js";
 import "./chunk-FYJ7W2PI.js";
+import "./chunk-Z7B6SRPM.js";
 import "./chunk-YP5KH5Y7.js";
-import "./chunk-PBRVUF5B.js";
+import "./chunk-K7JW6V5O.js";
 import "./chunk-ALMR3E6Q.js";
 import "./chunk-HIBNSEJE.js";
 import "./chunk-M5GB774H.js";
 import "./chunk-BKHCW2BI.js";
 import "./chunk-5HBA2Z7V.js";
-import "./chunk-DX3RGJMS.js";
-import "./chunk-UDXSXLER.js";
+import "./chunk-LT532KF4.js";
+import "./chunk-IW6RQPQB.js";
 import "./chunk-TWPJO254.js";
-import "./chunk-H6XPXXMH.js";
+import "./chunk-CQ35AJ4Z.js";
 import "./chunk-5O2XNYP6.js";
 import "./chunk-J2S4EL5Y.js";
 export {

package/chunks/{chunk-2PLNY5TN.js → chunk-23GFHEM3.js}

@@ -3,13 +3,13 @@
 import {
   resolveModelConfig,
   resolveProviderProtocol
-} from "./chunk-EI3NWELG.js";
+} from "./chunk-UIZGNLBP.js";
 import {
   external_exports
-} from "./chunk-H6XPXXMH.js";
+} from "./chunk-CQ35AJ4Z.js";
 import {
   stripRuntimeSnapshotPrefix
-} from "./chunk-TRRF5BSP.js";
+} from "./chunk-XT6TGJFD.js";
 import {
   REASONING_EFFORT_TIERS,
   normalizeReasoningEffort
@@ -17,7 +17,7 @@ import {
 import {
   AuthType,
   MODEL_GENERATION_CONFIG_FIELDS
-} from "./chunk-Y4R47ZUH.js";
+} from "./chunk-MDQSCFAZ.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-IIJEYBNH.js → chunk-25OFRBH2.js}

@@ -9,19 +9,19 @@ import {
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
-} from "./chunk-WOJZWRAZ.js";
+} from "./chunk-YRLW2MSX.js";
 import {
   defaultOutputCeiling,
   hasExplicitOutputLimit,
   parsePositiveIntegerEnvValue,
   tokenLimit
-} from "./chunk-ZBVS26BY.js";
+} from "./chunk-FPGTNKCP.js";
 import {
   buildRuntimeFetchOptions
-} from "./chunk-KKBPOU75.js";
+} from "./chunk-EFIMD5VA.js";
 import {
   createDebugLogger
-} from "./chunk-OIVKILPI.js";
+} from "./chunk-MPBRV3UU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -6952,6 +6952,9 @@ var DefaultOpenAICompatibleProvider = class {
   getDefaultGenerationConfig() {
     return {};
   }
+  getResponseParsingOptions() {
+    return { contentOnlyThinkingTagLeaks: true };
+  }
   /**
    * Apply output token limit to a request's max_tokens parameter.
    *
@@ -7019,6 +7022,78 @@ var DefaultOpenAICompatibleProvider = class {
 // packages/core/src/core/openaiContentGenerator/provider/dashscope.ts
 init_esbuild_shims();
 var debugLogger = createDebugLogger("DashScopeOpenAICompatibleProvider");
+function selectDashScopeThinkingKnob(model, extraBody, samplingParams, reasoningEffort) {
+  if (!isTieredEffortWireModel((model ?? "").toLowerCase())) {
+    return void 0;
+  }
+  const selectFromLayer = /* @__PURE__ */ __name((source, layer) => {
+    if (layer?.["enable_thinking"] === false) {
+      return { source, field: "enable_thinking", value: false };
+    }
+    return selectValueFromLayer(source, layer) ?? selectOnSwitch(source, layer);
+  }, "selectFromLayer");
+  const selectValueFromLayer = /* @__PURE__ */ __name((source, layer) => {
+    if (layer?.["reasoning_effort"] != null) {
+      return {
+        source,
+        field: "reasoning_effort",
+        value: layer["reasoning_effort"]
+      };
+    }
+    if (layer?.["thinking_budget"] != null) {
+      return {
+        source,
+        field: "thinking_budget",
+        value: layer["thinking_budget"]
+      };
+    }
+    return void 0;
+  }, "selectValueFromLayer");
+  const selectOnSwitch = /* @__PURE__ */ __name((source, layer) => {
+    if (layer?.["enable_thinking"] === true) {
+      return { source, field: "enable_thinking", value: true };
+    }
+    return void 0;
+  }, "selectOnSwitch");
+  const reasoningSelection = reasoningEffort !== void 0 ? {
+    source: "reasoning",
+    field: "reasoning_effort",
+    value: reasoningEffort
+  } : void 0;
+  const extraBodySelection = selectFromLayer("extra_body", extraBody);
+  if (extraBodySelection?.field === "enable_thinking" && extraBodySelection.value === true) {
+    return selectValueFromLayer("samplingParams", samplingParams) ?? reasoningSelection ?? extraBodySelection;
+  }
+  if (extraBodySelection) {
+    return extraBodySelection;
+  }
+  const samplingSelection = selectFromLayer("samplingParams", samplingParams);
+  return samplingSelection?.field === "enable_thinking" && samplingSelection.value === true ? reasoningSelection ?? samplingSelection : samplingSelection ?? reasoningSelection;
+}
+__name(selectDashScopeThinkingKnob, "selectDashScopeThinkingKnob");
+function withoutNullishThinkingKnobs(layer) {
+  if (!layer) {
+    return void 0;
+  }
+  const hasNullishEnableThinking = "enable_thinking" in layer && layer["enable_thinking"] == null;
+  const hasNullishEffort = "reasoning_effort" in layer && layer["reasoning_effort"] == null;
+  const hasNullishBudget = "thinking_budget" in layer && layer["thinking_budget"] == null;
+  if (!hasNullishEnableThinking && !hasNullishEffort && !hasNullishBudget) {
+    return layer;
+  }
+  const sanitized = { ...layer };
+  if (hasNullishEnableThinking) {
+    delete sanitized["enable_thinking"];
+  }
+  if (hasNullishEffort) {
+    delete sanitized["reasoning_effort"];
+  }
+  if (hasNullishBudget) {
+    delete sanitized["thinking_budget"];
+  }
+  return sanitized;
+}
+__name(withoutNullishThinkingKnobs, "withoutNullishThinkingKnobs");
 var DASHSCOPE_REGIONAL_HOSTS = [
   "dashscope.aliyuncs.com",
   "dashscope-intl.aliyuncs.com",
@@ -7031,9 +7106,6 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
   constructor(contentGeneratorConfig, cliConfig) {
     super(contentGeneratorConfig, cliConfig);
   }
-  getResponseParsingOptions() {
-    return { contentOnlyThinkingTagLeaks: true };
-  }
   /**
    * Determines whether to use the DashScope-compatible provider.
    * Covers the official regional hosts (DASHSCOPE_REGIONAL_HOSTS),
@@ -7139,13 +7211,23 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       tools = updatedTools;
     }
     const requestWithTokenLimits = this.applyOutputTokenLimit(request);
-    const extraBody = this.contentGeneratorConfig.extra_body;
+    const isTieredQwenModel = isTieredEffortWireModel(
+      this.resolveWireModel(request.model)
+    );
+    const extraBody = isTieredQwenModel ? withoutNullishThinkingKnobs(this.contentGeneratorConfig.extra_body) : this.contentGeneratorConfig.extra_body;
     const qwenEffortConfig = this.buildQwenEffortConfig(request.model);
-    const requestParams = requestWithTokenLimits;
+    const rawRequestParams = requestWithTokenLimits;
+    const requestParams = isTieredQwenModel ? withoutNullishThinkingKnobs(rawRequestParams) : rawRequestParams;
     if ("reasoning_effort" in requestParams && "reasoning_effort" in qwenEffortConfig) {
       qwenEffortConfig["reasoning_effort"] = requestParams["reasoning_effort"];
     }
     const hasQwenEffortConfig = Object.keys(qwenEffortConfig).length > 0;
+    const selectedThinkingKnob = isTieredQwenModel ? selectDashScopeThinkingKnob(
+      this.resolveWireModel(request.model),
+      extraBody,
+      requestParams,
+      qwenEffortConfig["reasoning_effort"]
+    ) : void 0;
     if (this.isVisionModel(request.model)) {
       const dashscopeExtras2 = {
         vl_high_resolution_images: true,
@@ -7153,7 +7235,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
         ...qwenEffortConfig
       };
       const visionResult = {
-        ...requestWithTokenLimits,
+        ...requestParams,
         messages,
         ...tools ? { tools } : {},
         ...this.buildMetadata(userPromptId) || {},
@@ -7165,7 +7247,8 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       return this.mergeExtraBodyAndResolveKnobs(
         visionResult,
         extraBody,
-        request.model
+        request.model,
+        selectedThinkingKnob
       );
     }
     const dashscopeExtras = {
@@ -7173,7 +7256,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
       ...qwenEffortConfig
     };
     const result = {
-      ...requestWithTokenLimits,
+      ...requestParams,
       // Preserve all original parameters including sampling params and adjusted max_tokens
       messages,
       ...tools ? { tools } : {},
@@ -7183,18 +7266,46 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
     if (hasQwenEffortConfig && "reasoning" in result) {
       delete result["reasoning"];
     }
-    return this.mergeExtraBodyAndResolveKnobs(result, extraBody, request.model);
+    return this.mergeExtraBodyAndResolveKnobs(
+      result,
+      extraBody,
+      request.model,
+      selectedThinkingKnob
+    );
   }
   /**
    * 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) {
+  mergeExtraBodyAndResolveKnobs(result, extraBody, model, selectedThinkingKnob) {
     const merged = {
       ...result,
       ...extraBody ? extraBody : {}
     };
-    this.dropConflictingThinkingKnobs(model, merged);
+    const reasoningEffort = merged["reasoning_effort"];
+    const dropped = /* @__PURE__ */ new Set();
+    if (selectedThinkingKnob?.field === "thinking_budget") {
+      if (reasoningEffort !== void 0) {
+        dropped.add("reasoning_effort");
+      }
+      if (merged["enable_thinking"] === false) {
+        dropped.add("enable_thinking");
+      }
+    }
+    if (selectedThinkingKnob?.field === "reasoning_effort" && merged["thinking_budget"] !== void 0) {
+      dropped.add("thinking_budget");
+    }
+    for (const key of dropped) {
+      delete merged[key];
+    }
+    for (const key of this.dropConflictingThinkingKnobs(
+      model,
+      merged,
+      selectedThinkingKnob
+    )) {
+      dropped.add(key);
+    }
+    this.warnConflictingKnobDrop(model, reasoningEffort, [...dropped]);
     return merged;
   }
   resolveWireModel(model) {
@@ -7227,60 +7338,78 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
    * 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;
-    }
+   * Only the qwen3.8-max family reads `reasoning_effort` itself — there an
+   * effort tier ships alone: an `enable_thinking: true` alongside an effort
+   * tier 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`. The `'none'`
+   * disable and a winning `thinking_budget` intentionally keep a co-present
+   * `enable_thinking: true`. Explicit same-layer effort/budget pairs retain
+   * reasoning_effort, matching the provider's behavior before cross-layer
+   * resolution. 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; a
+   * higher-priority `enable_thinking: true` conversely keeps the shipping
+   * tier. 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, selectedThinkingKnob) {
     const wireModel = this.resolveWireModel(model);
     if (!isQwenFamilyWireModel(wireModel)) {
-      return;
+      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) {
+    const isTieredEffortModel = isTieredEffortWireModel(wireModel);
+    if (isTieredEffortModel && selectedThinkingKnob?.field === "enable_thinking" && selectedThinkingKnob.value === false) {
+      merged["reasoning_effort"] = "none";
+      const dropped = ["enable_thinking"];
+      if (merged["thinking_budget"] !== void 0) {
         dropped.push("thinking_budget");
       }
-    } else if ("thinking_budget" in merged) {
-      dropped.push("reasoning_effort");
+      for (const key of dropped) {
+        delete merged[key];
+      }
+      return dropped;
     }
+    const effort = merged["reasoning_effort"];
+    if (typeof effort !== "string") {
+      return [];
+    }
+    if (isTieredEffortModel && effort === "none") {
+      if (merged["thinking_budget"] === void 0) {
+        return [];
+      }
+      delete merged["thinking_budget"];
+      return ["thinking_budget"];
+    }
+    if (isTieredEffortModel) {
+      if (selectedThinkingKnob?.field === "reasoning_effort" && "enable_thinking" in merged) {
+        delete merged["enable_thinking"];
+        return ["enable_thinking"];
+      }
+      return [];
+    }
+    if (merged["thinking_budget"] === void 0) {
+      return [];
+    }
+    delete merged["reasoning_effort"];
+    return ["reasoning_effort"];
+  }
+  warnConflictingKnobDrop(model, reasoningEffort, dropped) {
     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
-        }
-      );
+      debugLogger.warn("DashScope: dropped conflicting thinking knobs", {
+        model: this.resolveWireModel(model),
+        reasoningEffort,
+        dropped
+      });
     }
   }
   conflictingKnobDropWarned = false;
@@ -7473,6 +7602,7 @@ var DashScopeOpenAICompatibleProvider = class _DashScopeOpenAICompatibleProvider
 export {
   OpenAI,
   DefaultOpenAICompatibleProvider,
+  selectDashScopeThinkingKnob,
   DASHSCOPE_REGIONAL_HOSTS,
   DashScopeOpenAICompatibleProvider
 };