@qwen-code/qwen-code 0.20.2-headless-image-routing.1 → 0.21.0

package/chunks/chunk-2SCDWPXI.js

@@ -0,0 +1,246 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  require_semver
+} from "./chunk-DP3IHZGG.js";
+import {
+  getNpmCliPath
+} from "./chunk-ZNAUOR2I.js";
+import {
+  t
+} from "./chunk-LKEJ26GS.js";
+import {
+  getPackageJson
+} from "./chunk-VJNBRRZG.js";
+import {
+  createDebugLogger
+} from "./chunk-NL7LTRLR.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name,
+  __toESM
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/ui/utils/updateCheck.ts
+init_esbuild_shims();
+var import_semver = __toESM(require_semver(), 1);
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+var debugLogger = createDebugLogger("UPDATE_CHECK");
+var FETCH_TIMEOUT_MS = 5e3;
+var UpdateCheckTimeoutError = class extends Error {
+  static {
+    __name(this, "UpdateCheckTimeoutError");
+  }
+  distTag;
+  constructor(timeoutMs, distTag) {
+    const suffix = distTag ? ` for ${distTag}` : "";
+    super(`update check timed out after ${timeoutMs}ms${suffix}`);
+    this.name = "UpdateCheckTimeoutError";
+    this.distTag = distTag;
+  }
+};
+var NETWORK_ERROR_CODES = [
+  "ENOTFOUND",
+  "ECONNREFUSED",
+  "EAI_AGAIN",
+  "ETIMEDOUT",
+  "ENETUNREACH"
+];
+function classifyUpdateCheckError(error) {
+  if (error instanceof UpdateCheckTimeoutError) return "timeout";
+  if (error instanceof Error) {
+    if ("killed" in error && error.killed === true && "signal" in error && error.signal === "SIGTERM") {
+      return "timeout";
+    }
+    const errors = [error];
+    if (error.cause instanceof Error) errors.push(error.cause);
+    const matchesCode = /* @__PURE__ */ __name((code) => errors.some(
+      (error2) => error2.code === code || error2.message.includes(code)
+    ), "matchesCode");
+    if (NETWORK_ERROR_CODES.some(matchesCode)) return "offline";
+  }
+  return "registry";
+}
+__name(classifyUpdateCheckError, "classifyUpdateCheckError");
+function describeUpdateCheckFailure(error, timeoutMs = FETCH_TIMEOUT_MS) {
+  switch (classifyUpdateCheckError(error)) {
+    case "timeout":
+      return t("registry did not respond within {{seconds}}s", {
+        seconds: String(Math.round(timeoutMs / 1e3))
+      });
+    case "offline":
+      return t("registry unreachable");
+    default:
+      return t("registry error");
+  }
+}
+__name(describeUpdateCheckFailure, "describeUpdateCheckFailure");
+async function fetchInfoWithTimeout(notifier, timeoutMs, distTag) {
+  let timer;
+  try {
+    return await Promise.race([
+      Promise.resolve(notifier.fetchInfo()),
+      new Promise((_, reject) => {
+        timer = setTimeout(
+          () => reject(new UpdateCheckTimeoutError(timeoutMs, distTag)),
+          timeoutMs
+        );
+      })
+    ]);
+  } finally {
+    if (timer !== void 0) clearTimeout(timer);
+  }
+}
+__name(fetchInfoWithTimeout, "fetchInfoWithTimeout");
+var execFileAsync = promisify(execFile);
+async function runGlobalNpm(args, run = execFileAsync, platform = process.platform, nodePath = process.execPath, resolveNpmCliPath = getNpmCliPath) {
+  const { stdout } = await run(
+    nodePath,
+    [resolveNpmCliPath(nodePath, platform), ...args],
+    {
+      encoding: "utf8",
+      timeout: FETCH_TIMEOUT_MS
+    }
+  );
+  return String(stdout).trim();
+}
+__name(runGlobalNpm, "runGlobalNpm");
+async function fetchGlobalNpmUpdateInfo(packageName, currentVersion, distTag, run = execFileAsync) {
+  const output = await runGlobalNpm(
+    ["view", packageName, `dist-tags.${distTag}`, "--json", "--global"],
+    run
+  );
+  if (output === "") {
+    return {
+      latest: currentVersion,
+      current: currentVersion,
+      type: "latest",
+      name: packageName
+    };
+  }
+  const parsed = JSON.parse(output);
+  const latest = typeof parsed === "string" ? parsed : Array.isArray(parsed) && parsed.length === 1 && typeof parsed[0] === "string" ? parsed[0] : void 0;
+  if (latest === void 0) {
+    throw new Error(`Invalid npm ${distTag} version response`);
+  }
+  return {
+    latest,
+    current: currentVersion,
+    type: "latest",
+    name: packageName
+  };
+}
+__name(fetchGlobalNpmUpdateInfo, "fetchGlobalNpmUpdateInfo");
+function getBestAvailableUpdate(nightly, stable) {
+  if (!nightly) return stable || null;
+  if (!stable) return nightly || null;
+  const nightlyVer = nightly.latest;
+  const stableVer = stable.latest;
+  if (import_semver.default.coerce(stableVer)?.version === import_semver.default.coerce(nightlyVer)?.version) {
+    return nightly;
+  }
+  return import_semver.default.gt(stableVer, nightlyVer) ? stable : nightly;
+}
+__name(getBestAvailableUpdate, "getBestAvailableUpdate");
+async function checkForUpdatesDetailed(fetchGlobalNpm = fetchGlobalNpmUpdateInfo) {
+  let currentVersion;
+  try {
+    if (process.env["DEV"] === "true") {
+      return { status: "skipped", reason: "development mode" };
+    }
+    const packageJson = await getPackageJson();
+    if (!packageJson || !packageJson.name || !packageJson.version) {
+      return { status: "skipped", reason: "package metadata unavailable" };
+    }
+    const { name, version } = packageJson;
+    currentVersion = version;
+    const isNightly = version.includes("nightly");
+    const createNotifier = /* @__PURE__ */ __name((distTag) => ({
+      fetchInfo: /* @__PURE__ */ __name(() => fetchGlobalNpm(name, version, distTag), "fetchInfo")
+    }), "createNotifier");
+    if (isNightly) {
+      const [nightlyUpdateInfo, latestUpdateInfo] = await Promise.all([
+        fetchInfoWithTimeout(
+          createNotifier("nightly"),
+          FETCH_TIMEOUT_MS,
+          "nightly"
+        ),
+        fetchInfoWithTimeout(
+          createNotifier("latest"),
+          FETCH_TIMEOUT_MS,
+          "latest"
+        )
+      ]);
+      debugLogger.debug(
+        `fetchInfo returned nightly=${JSON.stringify(nightlyUpdateInfo)} latest=${JSON.stringify(latestUpdateInfo)} for current=${version}`
+      );
+      const bestUpdate = getBestAvailableUpdate(
+        nightlyUpdateInfo,
+        latestUpdateInfo
+      );
+      if (bestUpdate && import_semver.default.gt(bestUpdate.latest, version)) {
+        return {
+          status: "update",
+          info: {
+            message: t(
+              "A new version of Qwen Code is available! {{current}} \u2192 {{latest}}",
+              { current: version, latest: bestUpdate.latest }
+            ),
+            update: { ...bestUpdate, current: version }
+          }
+        };
+      }
+    } else {
+      const updateInfo = await fetchInfoWithTimeout(
+        createNotifier("latest"),
+        FETCH_TIMEOUT_MS,
+        "latest"
+      );
+      debugLogger.debug(
+        `fetchInfo returned ${JSON.stringify(updateInfo)} for current=${version}`
+      );
+      if (updateInfo && import_semver.default.gt(updateInfo.latest, version)) {
+        return {
+          status: "update",
+          info: {
+            message: t("Qwen Code update available! {{current}} \u2192 {{latest}}", {
+              current: version,
+              latest: updateInfo.latest
+            }),
+            update: { ...updateInfo, current: version }
+          }
+        };
+      }
+    }
+    return { status: "up-to-date", currentVersion: version };
+  } catch (e) {
+    const error = e instanceof Error ? e : new Error(String(e));
+    debugLogger.warn("Failed to check for updates: " + error);
+    return { status: "error", error, currentVersion };
+  }
+}
+__name(checkForUpdatesDetailed, "checkForUpdatesDetailed");
+async function checkForUpdates(fetchGlobalNpm = fetchGlobalNpmUpdateInfo) {
+  const result = await checkForUpdatesDetailed(fetchGlobalNpm);
+  return result.status === "update" ? result.info : null;
+}
+__name(checkForUpdates, "checkForUpdates");
+
+export {
+  FETCH_TIMEOUT_MS,
+  UpdateCheckTimeoutError,
+  classifyUpdateCheckError,
+  describeUpdateCheckFailure,
+  runGlobalNpm,
+  fetchGlobalNpmUpdateInfo,
+  checkForUpdatesDetailed,
+  checkForUpdates
+};
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-QE4KFTBS.js → chunk-2X55UKQE.js}

@@ -2,16 +2,16 @@
 "use strict";
 import {
   useKeypress
-} from "./chunk-SQFXI7VK.js";
+} from "./chunk-LQIW3YFY.js";
 import {
   require_react
 } from "./chunk-5QWWOFGG.js";
 import {
   t
-} from "./chunk-VRRF3GW5.js";
+} from "./chunk-LKEJ26GS.js";
 import {
   APPROVAL_MODES
-} from "./chunk-WHGVTP7Q.js";
+} from "./chunk-L26JL52R.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QBUDF33N.js → chunk-3QMGYBFN.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-3OAKYHRG.js → chunk-3RN6GBKS.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   BaseJsonOutputAdapter
-} from "./chunk-FRPDJNK3.js";
+} from "./chunk-BKHWX6I2.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-QR6U5QPP.js → chunk-3SJ43L4W.js}

@@ -13,8 +13,10 @@ var LOAD_REPLAY_BULK_MODE = "bulk";
 var LOAD_REPLAY_VERSION = 1;
 var CHANNEL_STARTUP_PROFILE_META_KEY = "qwen.daemon.channelStartupProfile";
 var CHANNEL_STARTUP_PROFILE_VERSION = 1;
+var DAEMON_CHANNEL_DELIVERY_META_KEY = "qwen.daemon.channelDelivery";
 var MID_TURN_QUEUE_DRAIN_METHOD = "craft/drainMidTurnQueue";
 var TODO_STOP_GUARD_QUEUE_RELEASE_METHOD = "craft/todoStopGuardQueueReleased";
+var PROMPT_CANCEL_METHOD = "craft/cancelPendingPrompt";
 var CLIENT_MCP_OVER_WS_CONFIG_FLAG = "__clientMcpOverWs";
 
 export {
@@ -25,8 +27,10 @@ export {
   LOAD_REPLAY_VERSION,
   CHANNEL_STARTUP_PROFILE_META_KEY,
   CHANNEL_STARTUP_PROFILE_VERSION,
+  DAEMON_CHANNEL_DELIVERY_META_KEY,
   MID_TURN_QUEUE_DRAIN_METHOD,
   TODO_STOP_GUARD_QUEUE_RELEASE_METHOD,
+  PROMPT_CANCEL_METHOD,
   CLIENT_MCP_OVER_WS_CONFIG_FLAG
 };
 /**

package/chunks/chunk-46UV252V.js

@@ -0,0 +1,128 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/utils/request-tokenizer/textTokenizer.ts
+init_esbuild_shims();
+var NON_ASCII_RE = /[\u0080-\uffff]/;
+var TOKEN_ESTIMATE_UNITS_PER_TOKEN = 20;
+function estimateTextTokens(text) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  if (!NON_ASCII_RE.test(text)) {
+    return Math.ceil(text.length / 4);
+  }
+  const nonAsciiChars = countNonAsciiChars(text);
+  const asciiChars = text.length - nonAsciiChars;
+  return Math.ceil(asciiChars / 4 + nonAsciiChars * 1.1);
+}
+__name(estimateTextTokens, "estimateTextTokens");
+function estimateTextTokenUnits(text) {
+  if (!text || text.length === 0) {
+    return 0;
+  }
+  if (!NON_ASCII_RE.test(text)) {
+    return text.length * 5;
+  }
+  const nonAsciiChars = countNonAsciiChars(text);
+  const asciiChars = text.length - nonAsciiChars;
+  return asciiChars * 5 + nonAsciiChars * 22;
+}
+__name(estimateTextTokenUnits, "estimateTextTokenUnits");
+function countNonAsciiChars(text) {
+  let count = 0;
+  for (let i = 0; i < text.length; i++) {
+    if (text.charCodeAt(i) >= 128) {
+      count++;
+    }
+  }
+  return count;
+}
+__name(countNonAsciiChars, "countNonAsciiChars");
+var TextTokenizer = class {
+  static {
+    __name(this, "TextTokenizer");
+  }
+  /**
+   * Calculate tokens for text content
+   *
+   * @param text - The text to estimate tokens for
+   * @returns The estimated token count
+   */
+  async calculateTokens(text) {
+    return this.calculateTokensSync(text);
+  }
+  /**
+   * Calculate tokens for multiple text strings
+   *
+   * @param texts - Array of text strings to estimate tokens for
+   * @returns Array of token counts corresponding to each input text
+   */
+  async calculateTokensBatch(texts) {
+    return texts.map((text) => this.calculateTokensSync(text));
+  }
+  calculateTokensSync(text) {
+    return estimateTextTokens(text);
+  }
+};
+
+// packages/core/src/utils/tool-name-utils.ts
+init_esbuild_shims();
+var MAX_TOOL_NAME_LENGTH = 63;
+var PROVIDER_SAFE_TOOL_NAME = /^[A-Za-z][A-Za-z0-9_-]*$/;
+function normalizeToolNameForProvider(name) {
+  if (name.length <= MAX_TOOL_NAME_LENGTH && PROVIDER_SAFE_TOOL_NAME.test(name)) {
+    return name;
+  }
+  const normalized = sanitizeToolNameForProvider(name);
+  const suffix = `_${stableToolNameHash(name)}`;
+  return `${normalized.slice(0, MAX_TOOL_NAME_LENGTH - suffix.length)}${suffix}`;
+}
+__name(normalizeToolNameForProvider, "normalizeToolNameForProvider");
+function sanitizeToolNameForProvider(name) {
+  const sanitized = name.replace(/[^A-Za-z0-9_-]/g, "_");
+  return /^[A-Za-z]/.test(sanitized) ? sanitized : `tool_${sanitized}`;
+}
+__name(sanitizeToolNameForProvider, "sanitizeToolNameForProvider");
+function normalizeMcpToolName(name) {
+  return name.startsWith("mcp__") ? normalizeToolNameForProvider(name) : name;
+}
+__name(normalizeMcpToolName, "normalizeMcpToolName");
+function generateLegacyMcpToolName(name) {
+  let legacyName = name.replace(/[^A-Za-z0-9_.-]/g, "_");
+  if (legacyName.length > MAX_TOOL_NAME_LENGTH) {
+    legacyName = legacyName.slice(0, 28) + "___" + legacyName.slice(-32);
+  }
+  return legacyName;
+}
+__name(generateLegacyMcpToolName, "generateLegacyMcpToolName");
+function stableToolNameHash(name) {
+  let hash = 2166136261;
+  for (let index = 0; index < name.length; index += 1) {
+    hash = Math.imul(hash ^ name.charCodeAt(index), 16777619);
+  }
+  return (hash >>> 0).toString(36).padStart(7, "0");
+}
+__name(stableToolNameHash, "stableToolNameHash");
+
+export {
+  TOKEN_ESTIMATE_UNITS_PER_TOKEN,
+  estimateTextTokens,
+  estimateTextTokenUnits,
+  TextTokenizer,
+  normalizeToolNameForProvider,
+  sanitizeToolNameForProvider,
+  normalizeMcpToolName,
+  generateLegacyMcpToolName
+};
+/**
+ * @license
+ * Copyright 2025 Qwen
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-GHRSKGHF.js → chunk-4WIZGAH3.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolveChannelCwd
-} from "./chunk-6ZBPS62S.js";
+} from "./chunk-7ZCNENPP.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -21,12 +21,12 @@ function ensureBuiltins() {
   if (!builtinsPromise) {
     builtinsPromise = (async () => {
       const labelled = [
-        { name: "telegram", promise: import("./dist-XBJVSWS2.js") },
-        { name: "weixin", promise: import("./dist-UIFWIFRO.js") },
-        { name: "dingtalk", promise: import("./dist-XRYV6TJP.js") },
-        { name: "wecom", promise: import("./dist-OAV7LJGJ.js") },
-        { name: "feishu", promise: import("./dist-OMW6WDEO.js") },
-        { name: "qqbot", promise: import("./dist-PJLG2XYX.js") }
+        { name: "telegram", promise: import("./dist-BBLXMS3N.js") },
+        { name: "weixin", promise: import("./dist-46NQKLTW.js") },
+        { name: "dingtalk", promise: import("./dist-AIKFMUKK.js") },
+        { name: "wecom", promise: import("./dist-YFNEUWSE.js") },
+        { name: "feishu", promise: import("./dist-F6IBUDR4.js") },
+        { name: "qqbot", promise: import("./dist-WEAHOXDM.js") }
       ];
       const results = await Promise.allSettled(labelled.map((l) => l.promise));
       for (let i = 0; i < results.length; i++) {

package/chunks/{chunk-CAS7CB3T.js → chunk-55DJUCI2.js}

@@ -3,10 +3,10 @@
 import {
   DashScopeOpenAICompatibleProvider,
   DefaultOpenAICompatibleProvider
-} from "./chunk-LESHKUWF.js";
+} from "./chunk-DLWL3Z7A.js";
 import {
   RequestTokenizer
-} from "./chunk-MDZTPSXO.js";
+} from "./chunk-OKY7HXPG.js";
 import {
   DEFAULT_STREAM_IDLE_TIMEOUT_MS,
   MAX_STREAM_IDLE_TIMEOUT_MS,
@@ -16,31 +16,46 @@ import {
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
 import {
-  InvalidStreamError,
   OpenAIContentConverter,
-  ProtocolTagSanitizedEvent,
   TaggedThinkingParser,
-  getRateLimitErrorDetails,
-  logProtocolTagSanitized,
   openaiRequestCaptureContext
-} from "./chunk-ZDP2Y2AL.js";
+} from "./chunk-DHHOYAPR.js";
+import {
+  InvalidStreamError
+} from "./chunk-BPJSQIJX.js";
+import {
+  getRateLimitErrorDetails
+} from "./chunk-6FGBXPWM.js";
 import {
-  getToolCallPreparations,
-  reconcileMaxTokens,
-  redactProxyError,
-  runtimeDiagnostics,
   safeJsonParse
-} from "./chunk-CBOQ3HY7.js";
+} from "./chunk-H5FFA6TH.js";
 import {
-  GenerateContentResponse
-} from "./chunk-TYQMGACW.js";
+  getToolCallPreparations,
+  runtimeDiagnostics
+} from "./chunk-LS77BEZP.js";
+import {
+  reportOpenAiRequest
+} from "./chunk-LEH5C7FV.js";
+import {
+  ProtocolTagSanitizedEvent,
+  logProtocolTagSanitized
+} from "./chunk-CIKQ7KKO.js";
+import {
+  reconcileMaxTokens
+} from "./chunk-UW5EOVUN.js";
+import {
+  redactProxyError
+} from "./chunk-2JZBVYTU.js";
 import {
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   getErrorType,
   isAbortError
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
+import {
+  GenerateContentResponse
+} from "./chunk-22C7BQ6D.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -884,6 +899,13 @@ var StreamingToolCallParser = class {
 
 // packages/core/src/core/openaiContentGenerator/pipeline.ts
 var debugLogger3 = createDebugLogger("OPENAI_PIPELINE");
+function isRequiredThinkingError(error) {
+  if (getErrorStatus(error) !== 400) return false;
+  const providerMessage = getRateLimitErrorDetails(error).providerMessage;
+  const message = `${getErrorMessage(error)} ${providerMessage ?? ""}`;
+  return message.includes("enable_thinking") && /(?:restricted to|must be) true\b/i.test(message);
+}
+__name(isRequiredThinkingError, "isRequiredThinkingError");
 var StreamContentError = class extends Error {
   static {
     __name(this, "StreamContentError");
@@ -1043,6 +1065,7 @@ var ContentGenerationPipeline = class {
   }
   client;
   contentGeneratorConfig;
+  requiredThinkingModels = /* @__PURE__ */ new Set();
   // Resolved once (config field > env > default) so the env read + any
   // invalid-value warning happen per pipeline, not per streaming request.
   streamIdleTimeoutMs;
@@ -1190,7 +1213,7 @@ var ContentGenerationPipeline = class {
         if (sanitization) {
           context.protocolTagSanitized = void 0;
         }
-        if (response.candidates?.[0]?.content?.parts?.length === 0 && !response.candidates?.[0]?.finishReason && !response.usageMetadata && // Preparation-only responses must reach ACP before arguments complete.
+        if ((response.candidates?.[0]?.content?.parts?.length ?? 0) === 0 && !response.candidates?.[0]?.finishReason && !response.usageMetadata && // Preparation-only responses must reach ACP before arguments complete.
         getToolCallPreparations(response).length === 0) {
           continue;
         }
@@ -1307,6 +1330,9 @@ var ContentGenerationPipeline = class {
         if (response.usageMetadata) {
           pendingFinishResponse.usageMetadata = response.usageMetadata;
         }
+        if (response.modelVersion) {
+          pendingFinishResponse.modelVersion = response.modelVersion;
+        }
         setPendingFinish(pendingFinishResponse);
       } else {
         setPendingFinish(response);
@@ -1320,10 +1346,10 @@ var ContentGenerationPipeline = class {
       } else {
         mergedResponse.usageMetadata = pendingFinishResponse.usageMetadata;
       }
-      mergedResponse.responseId = response.responseId;
-      mergedResponse.createTime = response.createTime;
-      mergedResponse.modelVersion = response.modelVersion;
-      mergedResponse.promptFeedback = response.promptFeedback;
+      mergedResponse.responseId = response.responseId || pendingFinishResponse.responseId;
+      mergedResponse.createTime = response.createTime || pendingFinishResponse.createTime;
+      mergedResponse.modelVersion = response.modelVersion || pendingFinishResponse.modelVersion;
+      mergedResponse.promptFeedback = response.promptFeedback || pendingFinishResponse.promptFeedback;
       setPendingFinish(mergedResponse);
       return true;
     }
@@ -1365,8 +1391,7 @@ var ContentGenerationPipeline = class {
     const isDashScope = DashScopeOpenAICompatibleProvider.isDashScopeProvider(
       this.contentGeneratorConfig
     );
-    const configModel = (this.contentGeneratorConfig.model ?? "").toLowerCase();
-    const thinkingMandatory = this.contentGeneratorConfig.thinkingMandatory === true && model === configModel;
+    const thinkingMandatory = this.requiresThinking(model);
     const reasoningDisabled = request.config?.thinkingConfig?.includeThoughts === false || this.contentGeneratorConfig.reasoning === false;
     if (reasoningDisabled) {
       const typed = providerRequest;
@@ -1385,24 +1410,38 @@ var ContentGenerationPipeline = class {
       if ("reasoning" in typed) {
         delete typed["reasoning"];
       }
-      if ("reasoning_effort" in typed) {
+      if ("reasoning_effort" in typed && typed["reasoning_effort"] !== "none") {
         delete typed["reasoning_effort"];
       }
       if (isDeepSeekHostname(this.contentGeneratorConfig)) {
         typed["thinking"] = { type: "disabled" };
       }
     }
-    if (thinkingMandatory && isDashScope) {
+    if (thinkingMandatory) {
       const typed = providerRequest;
       if (typed["enable_thinking"] === false) {
         delete typed["enable_thinking"];
       }
-      if (typed["tool_choice"] === "required") {
+      const chatTemplateKwargs = typed["chat_template_kwargs"];
+      if (chatTemplateKwargs?.["enable_thinking"] === false) {
+        const remaining = { ...chatTemplateKwargs };
+        delete remaining["enable_thinking"];
+        if (Object.keys(remaining).length > 0) {
+          typed["chat_template_kwargs"] = remaining;
+        } else {
+          delete typed["chat_template_kwargs"];
+        }
+      }
+      if (isDashScope && typed["tool_choice"] === "required") {
         delete typed["tool_choice"];
       }
     }
     return providerRequest;
   }
+  requiresThinking(model) {
+    const normalizedModel = model.toLowerCase();
+    return this.requiredThinkingModels.has(normalizedModel) || this.contentGeneratorConfig.thinkingMandatory === true && normalizedModel === (this.contentGeneratorConfig.model ?? "").toLowerCase();
+  }
   buildGenerateContentConfig(request) {
     const defaultSamplingParams = this.config.provider.getDefaultGenerationConfig();
     const configSamplingParams = this.contentGeneratorConfig.samplingParams;
@@ -1464,8 +1503,9 @@ var ContentGenerationPipeline = class {
    */
   async executeWithErrorHandling(request, userPromptId, isStreaming, executor) {
     const context = this.createRequestContext(request, isStreaming);
-    try {
-      const openaiRequest = await this.buildRequest(
+    let openaiRequest;
+    const executeAttempt = /* @__PURE__ */ __name(async () => {
+      openaiRequest = await this.buildRequest(
         request,
         userPromptId,
         context,
@@ -1473,9 +1513,27 @@ var ContentGenerationPipeline = class {
       );
       openaiRequestCaptureContext.getStore()?.(openaiRequest);
       runtimeDiagnostics.recordOpenAIWireRequest(openaiRequest);
-      const result = await executor(openaiRequest, context);
-      return result;
+      reportOpenAiRequest(openaiRequest);
+      return executor(openaiRequest, context);
+    }, "executeAttempt");
+    try {
+      return await executeAttempt();
     } catch (error) {
+      const model = context.model.toLowerCase();
+      const wireRequest = openaiRequest;
+      const chatTemplateKwargs = wireRequest?.["chat_template_kwargs"];
+      if ((wireRequest?.["enable_thinking"] === false || chatTemplateKwargs?.["enable_thinking"] === false) && request.config?.abortSignal?.aborted !== true && isRequiredThinkingError(error)) {
+        this.requiredThinkingModels.add(model);
+        debugLogger3.warn("Retrying with required thinking enabled", {
+          model,
+          originalError: getErrorMessage(error)
+        });
+        try {
+          return await executeAttempt();
+        } catch (retryError) {
+          return await this.handleError(retryError, context, request);
+        }
+      }
       return await this.handleError(error, context, request);
     }
   }