@qwen-code/qwen-code 0.20.2-jobbench-no-todo-write.0 → 0.21.0

package/chunks/{chunk-CI3GWKGJ.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-H4A4A2SY.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);
     }
   }

package/chunks/{chunk-QNLNLENL.js → chunk-5I2IWRSH.js}

@@ -2,11 +2,11 @@
 "use strict";
 import {
   atomicWriteFileSync
-} from "./chunk-6X4GWOPW.js";
+} from "./chunk-A5L3JMUA.js";
 import {
   Storage,
   createDebugLogger
-} from "./chunk-OQB4EXO4.js";
+} from "./chunk-NL7LTRLR.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-D7WXIW7H.js → chunk-5NBDS5S6.js}

@@ -2,9 +2,12 @@
 "use strict";
 import {
   CHANNEL_DAEMON_WORKER_SENTINEL,
+  CHANNEL_DELIVERY_IPC_TIMEOUT_MS,
   CHANNEL_WEBHOOK_TASK_IPC_TIMEOUT_MS,
   CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS,
+  ChannelDeliveryError,
   ChannelWebhookEnqueueError,
+  MAX_CHANNEL_DELIVERIES_IN_FLIGHT,
   MAX_CHANNEL_STARTUP_FAILURES,
   MAX_CHANNEL_STARTUP_FAILURE_CHANNEL_LENGTH,
   MAX_CHANNEL_STARTUP_FAILURE_CODE_LENGTH,
@@ -13,21 +16,23 @@ import {
   QWEN_DAEMON_URL_ENV,
   QWEN_DAEMON_WORKSPACE_ENV,
   QWEN_SERVER_TOKEN_ENV,
+  createChannelDeliveryMessage,
   createChannelWebhookTaskMessage,
   createWorkerDiagnosticRedactor,
+  isChannelDeliveryResultMessage,
   isChannelStartupReportMessage,
   isChannelStartupReportType,
   isChannelWebhookEnqueueErrorCode,
   isChannelWebhookTaskResultMessage,
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-QKTHJXCS.js";
+} from "./chunk-LK7CHLVP.js";
 import {
   channelSelectionNames
-} from "./chunk-TJTKSVIV.js";
+} from "./chunk-JLU636DO.js";
 import {
   sanitizeLogText
-} from "./chunk-RVLZCXEE.js";
+} from "./chunk-RWTEFFPU.js";
 import {
   CHANNEL_WORKER_KILL_GRACE_MS,
   CHANNEL_WORKER_STARTUP_TIMEOUT_MS,
@@ -263,6 +268,7 @@ function createChannelWorkerSupervisor(opts) {
   let staleHeartbeatTimer;
   let restartAttemptTimes = [];
   const pendingWebhookTasks = /* @__PURE__ */ new Map();
+  const pendingChannelDeliveries = /* @__PURE__ */ new Map();
   let restarting;
   let disposed = false;
   const snapshotCopy = /* @__PURE__ */ __name(() => ({
@@ -273,7 +279,8 @@ function createChannelWorkerSupervisor(opts) {
       startupFailures: snapshot.startupFailures.map((failure) => ({
         ...failure
       }))
-    } : {}
+    } : {},
+    ...snapshot.adapters ? { adapters: snapshot.adapters.map((adapter) => ({ ...adapter })) } : {}
   }), "snapshotCopy");
   const clearRestartTimer = /* @__PURE__ */ __name(() => {
     if (restartTimer) {
@@ -325,6 +332,39 @@ function createChannelWorkerSupervisor(opts) {
     }
     return true;
   }, "settleWebhookTask");
+  const rejectPendingChannelDeliveries = /* @__PURE__ */ __name((code, message) => {
+    for (const pending of pendingChannelDeliveries.values()) {
+      clearTimeout(pending.timer);
+      pending.reject(new ChannelDeliveryError(code, message));
+    }
+    pendingChannelDeliveries.clear();
+  }, "rejectPendingChannelDeliveries");
+  const rejectPendingChannelDelivery = /* @__PURE__ */ __name((id, error) => {
+    const pending = pendingChannelDeliveries.get(id);
+    if (!pending) return;
+    pendingChannelDeliveries.delete(id);
+    clearTimeout(pending.timer);
+    pending.reject(error);
+  }, "rejectPendingChannelDelivery");
+  const settleChannelDelivery = /* @__PURE__ */ __name((message) => {
+    if (!isChannelDeliveryResultMessage(message)) return false;
+    const pending = pendingChannelDeliveries.get(message.id);
+    if (!pending) return true;
+    if (message.ok) {
+      pendingChannelDeliveries.delete(message.id);
+      clearTimeout(pending.timer);
+      pending.resolve({ delivered: true });
+    } else {
+      rejectPendingChannelDelivery(
+        message.id,
+        new ChannelDeliveryError(
+          message.code,
+          message.error || "Channel delivery failed."
+        )
+      );
+    }
+    return true;
+  }, "settleChannelDelivery");
   const pruneRestartAttempts = /* @__PURE__ */ __name((nowMs) => {
     restartAttemptTimes = restartAttemptTimes.filter(
       (attemptMs) => nowMs - attemptMs < restartPolicy.windowMs
@@ -432,6 +472,12 @@ function createChannelWorkerSupervisor(opts) {
       state: "starting",
       channels: channelSelectionNames(opts.selection),
       ...requestedChannels ? { requestedChannels } : {},
+      ...requestedChannels ? {
+        adapters: requestedChannels.map((name) => ({
+          name,
+          state: "starting"
+        }))
+      } : {},
       startedAt,
       restartCount: snapshot.restartCount ?? 0,
       ...snapshot.lastExitAt ? { lastExitAt: snapshot.lastExitAt } : {},
@@ -615,7 +661,14 @@ function createChannelWorkerSupervisor(opts) {
         };
         snapshot = {
           ...snapshot,
-          startupFailures: [...snapshot.startupFailures ?? [], failure]
+          startupFailures: [...snapshot.startupFailures ?? [], failure],
+          adapters: snapshot.adapters?.map(
+            (adapter) => adapter.name === failure.channel ? {
+              name: adapter.name,
+              state: "error",
+              error: failure.message
+            } : adapter
+          )
         };
         acknowledgeStartupReport();
       }, "handleStartupReport");
@@ -637,6 +690,22 @@ function createChannelWorkerSupervisor(opts) {
         if (message.requestedChannels?.length) {
           next.requestedChannels = [...message.requestedChannels];
         }
+        const adapterNames = message.requestedChannels?.length ? message.requestedChannels : next.requestedChannels ?? next.channels;
+        const connected = new Set(next.channels);
+        const failures = new Map(
+          next.startupFailures?.map((failure) => [failure.channel, failure])
+        );
+        next.adapters = adapterNames.map((name) => {
+          if (connected.has(name)) {
+            return { name, state: "connected" };
+          }
+          const failure = failures.get(name);
+          return {
+            name,
+            state: "error",
+            ...failure ? { error: failure.message } : {}
+          };
+        });
         snapshot = next;
         armStaleHeartbeatTimer(startedChild);
         notifyReady(opts.onReady, snapshotCopy());
@@ -656,6 +725,9 @@ function createChannelWorkerSupervisor(opts) {
       }, "handleHeartbeat");
       function handleMessage(message) {
         if (child !== startedChild) return;
+        if (settleChannelDelivery(message)) {
+          return;
+        }
         if (settleWebhookTask(message)) {
           return;
         }
@@ -684,6 +756,10 @@ function createChannelWorkerSupervisor(opts) {
           "channel_worker_unavailable",
           "Channel worker exited."
         );
+        rejectPendingChannelDeliveries(
+          "channel_worker_unavailable",
+          "Channel worker exited."
+        );
         child = void 0;
         if ((ready || kind === "restart") && !stopping) {
           scheduleRestart();
@@ -759,6 +835,10 @@ function createChannelWorkerSupervisor(opts) {
         "channel_worker_unavailable",
         "Channel worker stopped."
       );
+      rejectPendingChannelDeliveries(
+        "channel_worker_unavailable",
+        "Channel worker stopped."
+      );
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         child = void 0;
         snapshot = { ...snapshot, state: "stopped" };
@@ -803,6 +883,10 @@ function createChannelWorkerSupervisor(opts) {
         "channel_worker_unavailable",
         "Channel worker stopped."
       );
+      rejectPendingChannelDeliveries(
+        "channel_worker_unavailable",
+        "Channel worker stopped."
+      );
       if (!child || snapshot.state === "exited" || snapshot.state === "failed" && hasObservedExit(snapshot) || snapshot.state === "stopped") {
         clearRestartTimer();
         clearStaleHeartbeatTimer();
@@ -825,6 +909,62 @@ function createChannelWorkerSupervisor(opts) {
     snapshot() {
       return snapshotCopy();
     },
+    async deliverChannelMessage(request) {
+      const startedChild = child;
+      if (!startedChild || snapshot.state !== "running") {
+        throw new ChannelDeliveryError(
+          "channel_worker_unavailable",
+          "Channel worker is not running."
+        );
+      }
+      const send = startedChild.send;
+      if (!send) {
+        throw new ChannelDeliveryError(
+          "channel_worker_unavailable",
+          "Channel worker IPC send failed."
+        );
+      }
+      if (pendingChannelDeliveries.size >= MAX_CHANNEL_DELIVERIES_IN_FLIGHT) {
+        throw new ChannelDeliveryError(
+          "channel_delivery_queue_full",
+          "Channel delivery queue is full."
+        );
+      }
+      const message = createChannelDeliveryMessage(request);
+      return await new Promise((resolve, reject) => {
+        const timer = setTimeout(() => {
+          pendingChannelDeliveries.delete(message.id);
+          reject(
+            new ChannelDeliveryError(
+              "channel_delivery_timeout",
+              "Channel delivery IPC timed out."
+            )
+          );
+        }, CHANNEL_DELIVERY_IPC_TIMEOUT_MS);
+        timer.unref();
+        pendingChannelDeliveries.set(message.id, { resolve, reject, timer });
+        try {
+          send.call(startedChild, message, (error) => {
+            if (!error) return;
+            rejectPendingChannelDelivery(
+              message.id,
+              new ChannelDeliveryError(
+                "channel_worker_unavailable",
+                `Channel worker IPC send failed: ${error.message}`
+              )
+            );
+          });
+        } catch (error) {
+          rejectPendingChannelDelivery(
+            message.id,
+            new ChannelDeliveryError(
+              "channel_worker_unavailable",
+              `Channel worker IPC send failed: ${error instanceof Error ? error.message : String(error)}`
+            )
+          );
+        }
+      });
+    },
     async enqueueWebhookTask(task) {
       const startedChild = child;
       if (!startedChild || snapshot.state !== "running") {

package/chunks/{chunk-E4IMU4Y5.js → chunk-63P4EL5V.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";