@qwen-code/qwen-code 0.23.1-preview.2 → 0.23.2-preview.0

package/chunks/{chunk-ZJ2LM2SI.js → chunk-2OR32P5M.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-7GZCCHJL.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-2Z3T52OC.js

@@ -0,0 +1,82 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/cli/src/serve/conversations/conversation-runtime-errors.ts
+init_esbuild_shims();
+var DEFAULT_MESSAGES = {
+  conversation_runtime_in_use: "The Conversations runtime is owned by another daemon.",
+  conversation_runtime_unavailable: "The Conversations runtime is temporarily unavailable.",
+  conversation_root_compromised: "The Conversations root could not be verified.",
+  conversation_runtime_ownership_compromised: "The Conversations runtime ownership state could not be verified."
+};
+var ConversationRuntimeOwnershipError = class extends Error {
+  constructor(code, retryable, options) {
+    super(DEFAULT_MESSAGES[code], options);
+    this.code = code;
+    this.retryable = retryable;
+    this.name = "ConversationRuntimeOwnershipError";
+  }
+  static {
+    __name(this, "ConversationRuntimeOwnershipError");
+  }
+  status = 503;
+};
+function conversationRuntimeInUseError() {
+  return new ConversationRuntimeOwnershipError(
+    "conversation_runtime_in_use",
+    true
+  );
+}
+__name(conversationRuntimeInUseError, "conversationRuntimeInUseError");
+function conversationRuntimeUnavailableError(cause) {
+  return new ConversationRuntimeOwnershipError(
+    "conversation_runtime_unavailable",
+    true,
+    { cause }
+  );
+}
+__name(conversationRuntimeUnavailableError, "conversationRuntimeUnavailableError");
+function conversationRuntimeOwnershipCompromisedError(cause) {
+  return new ConversationRuntimeOwnershipError(
+    "conversation_runtime_ownership_compromised",
+    false,
+    { cause }
+  );
+}
+__name(conversationRuntimeOwnershipCompromisedError, "conversationRuntimeOwnershipCompromisedError");
+function conversationRootCompromisedError(cause) {
+  return new ConversationRuntimeOwnershipError(
+    "conversation_root_compromised",
+    false,
+    { cause }
+  );
+}
+__name(conversationRootCompromisedError, "conversationRootCompromisedError");
+
+// packages/cli/src/serve/live/types.ts
+init_esbuild_shims();
+var LIVE_HOST_PROTOCOL_VERSION = 7;
+var LIVE_HOST_BUNDLE_ID = "com.alibaba.qwen-code.live-host";
+var LIVE_INPUT_AUDIO_EPOCH_BYTES = 8;
+
+export {
+  ConversationRuntimeOwnershipError,
+  conversationRuntimeInUseError,
+  conversationRuntimeUnavailableError,
+  conversationRuntimeOwnershipCompromisedError,
+  conversationRootCompromisedError,
+  LIVE_HOST_PROTOCOL_VERSION,
+  LIVE_HOST_BUNDLE_ID,
+  LIVE_INPUT_AUDIO_EPOCH_BYTES
+};
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-5FYGZ7E3.js → chunk-33MLFMCL.js}

@@ -11,11 +11,11 @@ import {
 } from "./chunk-HWVUSYSN.js";
 import {
   loadSettings
-} from "./chunk-RUMSY4ES.js";
+} from "./chunk-Q2F43WTJ.js";
 import {
   SkillManager,
   isSafeModeEnv
-} from "./chunk-TSLRORQR.js";
+} from "./chunk-43CI6YWJ.js";
 import {
   writeStderrLine
 } from "./chunk-7FA2II6K.js";

package/chunks/{chunk-RH344FKI.js → chunk-3BTHHXXE.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   resolvePath
-} from "./chunk-65GHQ4FX.js";
+} from "./chunk-XVTCSVBK.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-OFB36ZBA.js → chunk-3LPJ776W.js}

@@ -369,7 +369,7 @@ ${taskManagementToolGuidance}- **Parallel Tool Calls:** You can call multiple to
 - **Background Processes:** Use background execution with \`is_background: true\` for commands that are unlikely to stop on their own, e.g. \`node server.js\`. Do not append a trailing \`&\` when using the shell tool's managed background mode. If unsure, follow the active interaction mode's question guidance.
 - **Interactive Commands:** Try to avoid shell commands that are likely to require user interaction (e.g. \`git rebase -i\`). Use non-interactive versions of commands (e.g. \`npm init -y\` instead of \`npm init\`) when available, and otherwise remind the user that interactive shell commands are not supported and may cause hangs until canceled by the user.
 - **Questions:** ${interaction.questions}
-- **Subagent Delegation:** Use the '${ToolNames.AGENT}' tool with specialized agents when the task at hand matches the agent's description. Subagents are valuable for parallelizing independent queries or for protecting the main context window from excessive results, but they should not be used excessively when not needed. Importantly, avoid duplicating work that subagents are already doing - if you delegate research to a subagent, do not also perform the same searches yourself.
+- **Subagent Delegation:** Use the '${ToolNames.AGENT}' tool with specialized agents when the task at hand matches the agent's description. Subagents are valuable for parallelizing independent queries or for protecting the main context window from excessive results, but they should not be used excessively when not needed. Importantly, avoid duplicating work that subagents are already doing - if you delegate research to a subagent, do not also perform the same searches yourself. A background subagent's result arrives as a task notification in a later turn; while waiting, do not read its transcript, predict its findings, or launch a replacement for the same task.
 - **Codebase Search:** For simple, directed codebase searches (e.g. for a specific file/class/function) use the '${ToolNames.GREP}' or '${ToolNames.GLOB}' tools directly. For broader codebase exploration and deep research, use the '${ToolNames.AGENT}' tool with subagent_type=Explore. This is slower than using '${ToolNames.GREP}' or '${ToolNames.GLOB}' directly, so use this only when a simple, directed search proves to be insufficient or when your task will clearly require more than 3 queries.
 - **Respect Tool Decisions:** Tool permissions are enforced by the runtime. If a call is denied or canceled, respect that decision and do _not_ try the same action through another path. Retry only if the user subsequently requests that action.