@qwen-code/qwen-code 0.22.0 → 0.22.2-nightly.20260828.7357136dd1

package/chunks/{chunk-4F5WV4RF.js → chunk-ISKH4QX3.js}

@@ -12,37 +12,41 @@ import {
   revokeChannelWorkerPromptAuthorization
 } from "./chunk-Z7B6SRPM.js";
 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,
   MAX_CHANNEL_STARTUP_FAILURE_MESSAGE_LENGTH,
-  QWEN_DAEMON_TOKEN_ENV,
-  QWEN_DAEMON_URL_ENV,
-  QWEN_DAEMON_WORKSPACE_ENV,
-  QWEN_SERVER_TOKEN_ENV,
-  createChannelDeliveryMessage,
   createChannelWebhookTaskMessage,
-  isChannelDeliveryResultMessage,
   isChannelStartupReportMessage,
   isChannelStartupReportType,
   isChannelWebhookEnqueueErrorCode,
   isChannelWebhookTaskResultMessage
-} from "./chunk-ND7NOI4P.js";
+} from "./chunk-STUJ7IMZ.js";
+import {
+  CHANNEL_DAEMON_WORKER_SENTINEL,
+  CHANNEL_WORKER_HEARTBEAT_INTERVAL_MS,
+  QWEN_DAEMON_TOKEN_ENV,
+  QWEN_DAEMON_URL_ENV,
+  QWEN_DAEMON_WORKSPACE_ENV,
+  QWEN_SERVER_TOKEN_ENV
+} from "./chunk-GYTKQYDB.js";
 import {
   createWorkerDiagnosticRedactor,
   normalizeWorkerDiagnostic,
   sanitizeWorkerDiagnostic
-} from "./chunk-A6NRNRKE.js";
+} from "./chunk-RFIDDFAL.js";
 import {
   channelSelectionNames
 } from "./chunk-ALMR3E6Q.js";
+import {
+  CHANNEL_DELIVERY_IPC_TIMEOUT_MS,
+  ChannelDeliveryError,
+  MAX_CHANNEL_DELIVERIES_IN_FLIGHT,
+  createChannelDeliveryMessage,
+  isChannelDeliveryResultMessage
+} from "./chunk-RKFGE7JH.js";
 import {
   EXTERNAL_TOOL_GUARD_TOKEN_ENV
 } from "./chunk-3VUENPWF.js";
@@ -53,7 +57,7 @@ import {
 } from "./chunk-5HBA2Z7V.js";
 import {
   sanitizeLogText
-} from "./chunk-AW27A43Y.js";
+} from "./chunk-ICURCKIU.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -65,6 +69,124 @@ import {
 init_esbuild_shims();
 import { fork } from "node:child_process";
 import { randomUUID } from "node:crypto";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+
+// packages/cli/src/serve/pem-certificate-blocks.ts
+init_esbuild_shims();
+import { spawnSync } from "node:child_process";
+import { X509Certificate } from "node:crypto";
+import { mkdtempSync, rmSync, writeFileSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+var NODE_EXTRA_CA_CERTS_ENV = "NODE_EXTRA_CA_CERTS";
+var ORACLE_TIMEOUT_MS = 1e4;
+var ORACLE_MAX_BUFFER_BYTES = 16 * 1024 * 1024;
+var ORACLE_SOURCE = `
+const tls = require('node:tls');
+if (typeof tls.getCACertificates === 'function') {
+  process.stdout.write(JSON.stringify({
+    certificates: tls.getCACertificates('extra'),
+  }));
+} else {
+  tls.createSecureContext();
+  process.stdout.write(JSON.stringify({ legacy: true }));
+}
+`;
+var ExtraCaInspectionError = class extends Error {
+  static {
+    __name(this, "ExtraCaInspectionError");
+  }
+};
+var LegacyExtraCaInspectionError = class extends ExtraCaInspectionError {
+  static {
+    __name(this, "LegacyExtraCaInspectionError");
+  }
+  constructor() {
+    super("Inspecting NODE_EXTRA_CA_CERTS requires Node.js 22.15.0 or newer.");
+  }
+};
+var FailedExtraCaInspectionError = class extends ExtraCaInspectionError {
+  static {
+    __name(this, "FailedExtraCaInspectionError");
+  }
+  constructor() {
+    super(
+      "Inspecting NODE_EXTRA_CA_CERTS failed before its contents could be judged."
+    );
+  }
+};
+function scanCertificateBlocks(contents, sourcePath) {
+  let dir;
+  try {
+    dir = sourcePath ? void 0 : mkdtempSync(join(tmpdir(), "qwen-ca-oracle-"));
+    const certPath = sourcePath ?? join(dir, "extra-ca.pem");
+    if (dir) writeFileSync(certPath, contents, { mode: 384 });
+    const oracleEnv = {
+      ...process.env,
+      [NODE_EXTRA_CA_CERTS_ENV]: certPath
+    };
+    for (const key of Object.keys(oracleEnv)) {
+      if (key.toUpperCase() === "NODE_OPTIONS") delete oracleEnv[key];
+    }
+    const result = spawnSync(
+      process.execPath,
+      ["--no-deprecation", "--input-type=commonjs", "-e", ORACLE_SOURCE],
+      {
+        encoding: "utf8",
+        env: oracleEnv,
+        maxBuffer: ORACLE_MAX_BUFFER_BYTES,
+        timeout: ORACLE_TIMEOUT_MS,
+        windowsHide: true
+      }
+    );
+    if (result.error || result.status !== 0) {
+      throw new FailedExtraCaInspectionError();
+    }
+    const parsed = JSON.parse(result.stdout);
+    if (typeof parsed !== "object" || parsed === null) {
+      throw new FailedExtraCaInspectionError();
+    }
+    const certificates = Reflect.get(parsed, "certificates");
+    if (certificates !== void 0) {
+      if (!Array.isArray(certificates) || !certificates.every((item) => typeof item === "string")) {
+        throw new FailedExtraCaInspectionError();
+      }
+      return certificates.map((block) => ({
+        block: block.trimEnd(),
+        certificate: new X509Certificate(block)
+      }));
+    }
+    if (Reflect.get(parsed, "legacy") !== true) {
+      throw new FailedExtraCaInspectionError();
+    }
+    throw new LegacyExtraCaInspectionError();
+  } catch (error) {
+    if (error instanceof ExtraCaInspectionError) throw error;
+    throw new FailedExtraCaInspectionError();
+  } finally {
+    if (dir) {
+      try {
+        rmSync(dir, { recursive: true, force: true });
+      } catch {
+      }
+    }
+  }
+}
+__name(scanCertificateBlocks, "scanCertificateBlocks");
+function extractCertificateBlocks(contents, sourcePath) {
+  const scanned = scanCertificateBlocks(contents, sourcePath);
+  return scanned.length > 0 ? scanned.map((entry) => entry.block) : void 0;
+}
+__name(extractCertificateBlocks, "extractCertificateBlocks");
+function loadableCertificates(contents, sourcePath) {
+  const scanned = scanCertificateBlocks(contents, sourcePath);
+  return scanned.length > 0 ? scanned.map((entry) => entry.certificate) : void 0;
+}
+__name(loadableCertificates, "loadableCertificates");
+
+// packages/cli/src/serve/channel-worker-supervisor.ts
 var DEFAULT_CHANNEL_WORKER_HEARTBEAT_TIMEOUT_MS = 45e3;
 var MAX_WORKER_LOG_LINE_LENGTH = 4096;
 var MAX_WORKER_LOG_BUFFER_LENGTH = 64 * 1024;
@@ -181,10 +303,151 @@ function hasObservedExit(snapshot) {
   return snapshot.exitCode !== void 0 || snapshot.signal !== void 0;
 }
 __name(hasObservedExit, "hasObservedExit");
+var NODE_EXTRA_CA_CERTS_ENV2 = "NODE_EXTRA_CA_CERTS";
+var mergedWorkerCaBundles = /* @__PURE__ */ new Map();
+function sourceStamp(filePath) {
+  const stat = fs.statSync(filePath);
+  return `${stat.mtimeMs}:${stat.size}`;
+}
+__name(sourceStamp, "sourceStamp");
+var warnedWorkerCaMergeFallbacks = /* @__PURE__ */ new Set();
+var WORKER_CA_MERGE_FALLBACK_FAMILIES = [
+  "read-error",
+  "inspection-failed",
+  "no-operator-blocks",
+  "no-daemon-blocks"
+];
+function workerCaMergeFallbackKey(operatorCaPath, daemonCertPath, family) {
+  return `${operatorCaPath}\0${daemonCertPath}\0${family}`;
+}
+__name(workerCaMergeFallbackKey, "workerCaMergeFallbackKey");
+function warnWorkerCaMergeFallback(operatorCaPath, daemonCertPath, family, reason) {
+  const key = workerCaMergeFallbackKey(operatorCaPath, daemonCertPath, family);
+  if (warnedWorkerCaMergeFallbacks.has(key)) return;
+  warnedWorkerCaMergeFallbacks.add(key);
+  process.emitWarning(
+    `qwen: failed to merge ${NODE_EXTRA_CA_CERTS_ENV2} "${operatorCaPath}" with the daemon cert "${daemonCertPath}": ${reason}; channel workers will trust only the daemon cert`
+  );
+}
+__name(warnWorkerCaMergeFallback, "warnWorkerCaMergeFallback");
+var mintedWorkerCaBundleDirs = /* @__PURE__ */ new Set();
+var workerCaBundleExitHookRegistered = false;
+function cleanupWorkerCaBundleDir(dir) {
+  try {
+    fs.rmSync(dir, { recursive: true, force: true });
+  } catch {
+  }
+}
+__name(cleanupWorkerCaBundleDir, "cleanupWorkerCaBundleDir");
+function writeMergedWorkerCaBundle(contents) {
+  const dir = fs.mkdtempSync(path.join(os.tmpdir(), "qwen-worker-ca-"));
+  mintedWorkerCaBundleDirs.add(dir);
+  if (!workerCaBundleExitHookRegistered) {
+    workerCaBundleExitHookRegistered = true;
+    process.once("exit", cleanupMintedWorkerCaBundleDirs);
+  }
+  const bundlePath = path.join(dir, "ca-bundle.pem");
+  fs.writeFileSync(bundlePath, contents, { mode: 384 });
+  return bundlePath;
+}
+__name(writeMergedWorkerCaBundle, "writeMergedWorkerCaBundle");
+function cleanupMintedWorkerCaBundleDirs() {
+  const swept = [...mintedWorkerCaBundleDirs];
+  for (const minted of swept) {
+    cleanupWorkerCaBundleDir(minted);
+  }
+  mintedWorkerCaBundleDirs.clear();
+  return swept;
+}
+__name(cleanupMintedWorkerCaBundleDirs, "cleanupMintedWorkerCaBundleDirs");
+function resolveWorkerCaCertPath(daemonCertPath, existing) {
+  if (!existing || existing === daemonCertPath) return daemonCertPath;
+  const cacheKey = `${existing}\0${daemonCertPath}`;
+  const sources = [existing, daemonCertPath];
+  const cached = mergedWorkerCaBundles.get(cacheKey);
+  if (cached) {
+    try {
+      fs.statSync(cached.bundlePath);
+      if (sources.every((src, i) => sourceStamp(src) === cached.sourceStamps[i])) {
+        return cached.bundlePath;
+      }
+    } catch {
+    }
+  }
+  try {
+    const sourceStamps = sources.map(sourceStamp);
+    const operatorBlocks = extractCertificateBlocks(
+      fs.readFileSync(existing, "utf8"),
+      existing
+    );
+    if (!operatorBlocks) {
+      warnWorkerCaMergeFallback(
+        existing,
+        daemonCertPath,
+        "no-operator-blocks",
+        // Three causes reject a file, not one: markers, decoding, and DER.
+        // Blaming markers alone tells an operator whose CA is truncated or
+        // hand-edited to fix lines that are already correct — and after boot
+        // this warning is the only diagnostic they get, so it has to name the
+        // same three the boot-time check does.
+        "it holds no PEM certificate block Node can load (every -----BEGIN/END CERTIFICATE----- marker must sit alone on its own line and every block must decode, and a DER file is never read at all)"
+      );
+      return daemonCertPath;
+    }
+    const daemonBlocks = extractCertificateBlocks(
+      fs.readFileSync(daemonCertPath, "utf8"),
+      daemonCertPath
+    );
+    if (!daemonBlocks) {
+      warnWorkerCaMergeFallback(
+        existing,
+        daemonCertPath,
+        "no-daemon-blocks",
+        "the daemon cert holds no PEM certificate block to merge into"
+      );
+      return daemonCertPath;
+    }
+    const bundlePath = writeMergedWorkerCaBundle(
+      `${[...operatorBlocks, ...daemonBlocks].join("\n")}
+`
+    );
+    const superseded = mergedWorkerCaBundles.get(cacheKey);
+    mergedWorkerCaBundles.set(cacheKey, { bundlePath, sourceStamps });
+    if (superseded) {
+      const dir = path.dirname(superseded.bundlePath);
+      mintedWorkerCaBundleDirs.delete(dir);
+      cleanupWorkerCaBundleDir(dir);
+    }
+    for (const family of WORKER_CA_MERGE_FALLBACK_FAMILIES) {
+      warnedWorkerCaMergeFallbacks.delete(
+        workerCaMergeFallbackKey(existing, daemonCertPath, family)
+      );
+    }
+    return bundlePath;
+  } catch (err) {
+    warnWorkerCaMergeFallback(
+      existing,
+      daemonCertPath,
+      // An inspection that could not run blames nothing about the file's
+      // contents; sharing the read-error family would let a first ENOENT
+      // silence the later, now-accurate inspection-failure diagnosis.
+      err instanceof ExtraCaInspectionError ? "inspection-failed" : "read-error",
+      err instanceof Error ? err.message : String(err)
+    );
+    return daemonCertPath;
+  }
+}
+__name(resolveWorkerCaCertPath, "resolveWorkerCaCertPath");
 function createWorkerEnv(opts) {
   const env = { ...opts.baseEnv ?? process.env };
   env["QWEN_CODE_NO_RELAUNCH"] = "true";
   env["QWEN_CODE_SERVE"] = "1";
+  if (opts.tlsCaCertPath) {
+    env[NODE_EXTRA_CA_CERTS_ENV2] = resolveWorkerCaCertPath(
+      opts.tlsCaCertPath,
+      env[NODE_EXTRA_CA_CERTS_ENV2]
+    );
+  }
   env[CHANNEL_DAEMON_WORKER_SENTINEL] = randomUUID();
   env[QWEN_DAEMON_URL_ENV] = opts.daemonUrl;
   env[QWEN_DAEMON_WORKSPACE_ENV] = opts.workspace;
@@ -505,7 +768,8 @@ function createChannelWorkerSupervisor(opts) {
       daemonUrl: opts.daemonUrl,
       workspace: opts.workspace,
       ...opts.daemonToken ? { daemonToken: opts.daemonToken } : {},
-      ...opts.workerBaseEnv ? { baseEnv: opts.workerBaseEnv } : {}
+      ...opts.workerBaseEnv ? { baseEnv: opts.workerBaseEnv } : {},
+      ...opts.tlsCaCertPath ? { tlsCaCertPath: opts.tlsCaCertPath } : {}
     });
     const promptAuthorization = env[CHANNEL_DAEMON_WORKER_SENTINEL];
     registerChannelWorkerPromptAuthorization(
@@ -1205,7 +1469,16 @@ function createChannelWorkerSupervisor(opts) {
 __name(createChannelWorkerSupervisor, "createChannelWorkerSupervisor");
 
 export {
+  ExtraCaInspectionError,
+  loadableCertificates,
   ChannelWorkerStopError,
   ChannelWorkerStartupError,
+  cleanupMintedWorkerCaBundleDirs,
+  resolveWorkerCaCertPath,
   createChannelWorkerSupervisor
 };
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */

package/chunks/{chunk-SE55HQGF.js → chunk-J6S24ZJE.js}

@@ -1,16 +1,16 @@
 // Force strict mode and setup for ESM
 "use strict";
 import {
-  RequestTokenizer
-} from "./chunk-IO257NUD.js";
+  parseToolCallArguments
+} from "./chunk-ZYNTSXWK.js";
 import {
   OpenAIContentConverter,
   TaggedThinkingParser,
   openaiRequestCaptureContext
-} from "./chunk-B6UBOIFE.js";
+} from "./chunk-H33EQVMG.js";
 import {
   safeJsonParse
-} from "./chunk-36OF5PRW.js";
+} from "./chunk-ABS25QER.js";
 import {
   runtimeDiagnostics
 } from "./chunk-VNOVK4I7.js";
@@ -18,64 +18,61 @@ import {
   reportOpenAiChunk,
   reportOpenAiRequest,
   reportOpenAiResponse
-} from "./chunk-IBJ5S45N.js";
+} from "./chunk-B7CDU2SL.js";
 import {
   applyOfficialOpenAIPromptCaching,
   isOfficialOpenAIEndpoint
-} from "./chunk-SAH4BD2J.js";
+} from "./chunk-PQEISIKS.js";
 import {
   DashScopeOpenAICompatibleProvider,
   DefaultOpenAICompatibleProvider
-} from "./chunk-VSNPOSDN.js";
+} from "./chunk-EB6QRGHM.js";
 import {
   getCurrentAgentId
-} from "./chunk-I432KXWD.js";
+} from "./chunk-CMHFCLBU.js";
 import {
-  getTransportCode
-} from "./chunk-7IV52LTO.js";
+  InvalidStreamError,
+  getToolCallPreparations
+} from "./chunk-CFKIH3D3.js";
 import {
   DEFAULT_STREAM_IDLE_TIMEOUT_MS,
   DEFAULT_STREAM_MAX_LIFETIME_MS,
   MAX_STREAM_GUARD_TIMEOUT_MS,
   QWEN_STREAM_IDLE_TIMEOUT_MS_ENV,
-  QWEN_STREAM_MAX_LIFETIME_MS_ENV
-} from "./chunk-AXMWHKXA.js";
+  QWEN_STREAM_MAX_LIFETIME_MS_ENV,
+  REASONING_EFFORT_TIERS
+} from "./chunk-2LD5U7Q3.js";
 import {
   createChildAbortController
 } from "./chunk-DJ2GSRLV.js";
 import {
-  InvalidStreamError
-} from "./chunk-2J3OJGTL.js";
-import {
-  getRateLimitErrorDetails
-} from "./chunk-LI4YHTQK.js";
-import {
-  getToolCallPreparations
-} from "./chunk-QKBYFU2Q.js";
+  getRateLimitErrorDetails,
+  getTransportCode
+} from "./chunk-DYXFD5RO.js";
 import {
   ProtocolTagSanitizedEvent,
   logProtocolTagSanitized
-} from "./chunk-FDD2IUEL.js";
+} from "./chunk-SZLBBZH4.js";
 import {
   isQwenFamilyWireModel,
   isTieredEffortWireModel
-} from "./chunk-YRLW2MSX.js";
+} from "./chunk-XBVNNDPK.js";
 import {
   reconcileMaxTokens
 } from "./chunk-FPGTNKCP.js";
 import {
   redactProxyError
-} from "./chunk-PZRUV52H.js";
+} from "./chunk-PPKZ7JOE.js";
 import {
   isInForkExecution
-} from "./chunk-WZDM44SB.js";
+} from "./chunk-CAJTKR6W.js";
 import {
   createDebugLogger,
   getErrorMessage,
   getErrorStatus,
   getErrorType,
   isAbortError
-} from "./chunk-A5F2YNO6.js";
+} from "./chunk-UHQFIS7N.js";
 import {
   GenerateContentResponse
 } from "./chunk-64REQJJ2.js";
@@ -180,16 +177,28 @@ var DeepSeekOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProv
   static isDeepSeekProvider = isDeepSeekProvider;
   static isDeepSeekHostname = isDeepSeekHostname;
   /**
-   * DeepSeek's API requires message content to be a plain string, not an
-   * array of content parts. Flatten any text-part arrays into joined
-   * strings; non-text parts (image_url, audio, …) are replaced with a
-   * `[Unsupported content type: <type>]` placeholder so the request still
-   * goes through with a textual breadcrumb rather than silently dropping
-   * the part or raising mid-conversation. Also translate the standard
-   * `reasoning.effort` config into DeepSeek's flat `reasoning_effort`
-   * body parameter — but only on actual DeepSeek hostnames, since the
-   * model-name fallback above can match self-hosted/strict OpenAI-compat
-   * backends that don't accept the DeepSeek extension.
+   * The full ladder, including `max`, only on a verified DeepSeek host.
+   * `isDeepSeekProvider` also routes here on a `deepseek` substring in the
+   * model name, which says nothing about what the endpoint accepts, so the
+   * capability follows the rule the module comment above already states: a
+   * decision about the wire shape DeepSeek's own API exposes uses
+   * `isDeepSeekHostname`. Elsewhere the generic ceiling applies.
+   */
+  supportedReasoningEffortsFor(model) {
+    return isDeepSeekHostname(this.contentGeneratorConfig) ? REASONING_EFFORT_TIERS : super.supportedReasoningEffortsFor(model);
+  }
+  /**
+   * Text-only DeepSeek APIs require message content to be a plain string, not
+   * an array of content parts. Flatten text-only request arrays into joined
+   * strings; non-text parts (image_url, audio, …) are replaced with an
+   * `[Unsupported content type: <type>]` placeholder so the request still goes
+   * through with a textual breadcrumb rather than silently dropping the part
+   * or raising mid-conversation. Models that explicitly declare image input
+   * retain multipart content for compatible gateways. Also translate the
+   * standard `reasoning.effort` config into DeepSeek's flat `reasoning_effort`
+   * body parameter — but only on actual DeepSeek hostnames, since the model-name
+   * fallback above can match self-hosted/strict OpenAI-compat backends that
+   * don't accept the DeepSeek extension.
    */
   buildRequest(request, userPromptId) {
     const baseRequest = super.buildRequest(request, userPromptId);
@@ -197,10 +206,11 @@ var DeepSeekOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProv
     if (!reshaped.messages?.length) {
       return reshaped;
     }
-    const messages = reshaped.messages.map((message) => {
-      const flattened = flattenContentParts(message);
-      return ensureReasoningContentOnAssistantMessage(flattened);
-    });
+    const messages = reshaped.messages.map(
+      (message) => ensureReasoningContentOnAssistantMessage(
+        this.contentGeneratorConfig.modalities?.image ? message : flattenContentParts(message)
+      )
+    );
     return {
       ...reshaped,
       messages
@@ -286,6 +296,19 @@ function isZaiProvider(contentGeneratorConfig) {
   return model.toLowerCase().startsWith("glm-");
 }
 __name(isZaiProvider, "isZaiProvider");
+function isGlmTieredEffortModel(model) {
+  if (!model) {
+    return false;
+  }
+  const parsed = /^glm-(\d+)(?:\.(\d+))?/.exec(model.toLowerCase());
+  if (!parsed) {
+    return false;
+  }
+  const major = Number(parsed[1]);
+  const minor = Number(parsed[2] ?? 0);
+  return major > 5 || major === 5 && minor >= 2;
+}
+__name(isGlmTieredEffortModel, "isGlmTieredEffortModel");
 var ZaiOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProvider {
   static {
     __name(this, "ZaiOpenAICompatibleProvider");
@@ -294,6 +317,17 @@ var ZaiOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProvider
   static isZaiHostname = isZaiHostname;
   // Latch so the skipped-flatten warning fires once per provider lifetime.
   nonZaiHostnameFlattenWarned = false;
+  /**
+   * The full ladder, including `max`, only on a verified Z.ai host running a
+   * GLM-5.2+ model. Both halves matter: `isZaiProvider` also routes here on a
+   * bare `glm-*` model name, which says nothing about what an arbitrary
+   * self-hosted backend accepts, and older GLM ids predate the tiered field.
+   * Anything else keeps the generic ceiling, matching the hostname gate the
+   * wire reshape below already uses.
+   */
+  supportedReasoningEffortsFor(model) {
+    return isZaiHostname(this.contentGeneratorConfig) && isGlmTieredEffortModel(model ?? this.contentGeneratorConfig.model) ? REASONING_EFFORT_TIERS : super.supportedReasoningEffortsFor(model);
+  }
   buildRequest(request, userPromptId) {
     const baseRequest = super.buildRequest(request, userPromptId);
     if (isZaiHostname(this.contentGeneratorConfig)) {
@@ -456,6 +490,20 @@ var MiMoOpenAICompatibleProvider = class extends DefaultOpenAICompatibleProvider
 // packages/core/src/core/openaiContentGenerator/pipeline.ts
 init_esbuild_shims();
 
+// packages/core/src/core/openaiContentGenerator/provider/openrouter.ts
+init_esbuild_shims();
+function isOpenRouterHostname(contentGeneratorConfig) {
+  const baseUrl = contentGeneratorConfig.baseUrl ?? "";
+  if (!baseUrl) return false;
+  try {
+    const hostname = new URL(baseUrl).hostname.toLowerCase();
+    return hostname === "openrouter.ai" || hostname.endsWith(".openrouter.ai");
+  } catch {
+    return false;
+  }
+}
+__name(isOpenRouterHostname, "isOpenRouterHostname");
+
 // packages/core/src/core/openaiContentGenerator/streamingToolCallParser.ts
 init_esbuild_shims();
 var debugLogger2 = createDebugLogger("STREAMING_TOOL_CALL_PARSER");
@@ -705,14 +753,7 @@ var StreamingToolCallParser = class {
   hasInvalidToolCallArguments() {
     for (const [index, buffer] of this.buffers.entries()) {
       if (!this.toolCallMeta.get(index)?.name || buffer.length === 0) continue;
-      try {
-        const args = JSON.parse(buffer);
-        if (typeof args !== "object" || args === null || Array.isArray(args)) {
-          return true;
-        }
-      } catch {
-        return true;
-      }
+      if (!parseToolCallArguments(buffer).ok) return true;
     }
     return false;
   }
@@ -1020,7 +1061,7 @@ var StreamContentError = class extends Error {
 var StreamInactivityTimeoutError = class extends Error {
   constructor(idleMs, chunksReceived, streamLifetimeMs) {
     super(
-      `No stream activity for ${idleMs}ms after ${chunksReceived} chunks (stream lifetime: ${streamLifetimeMs}ms). Set ${QWEN_STREAM_IDLE_TIMEOUT_MS_ENV} to increase this window (or 0 to disable it).`
+      `No stream activity for ${idleMs}ms after ${chunksReceived} chunks (stream lifetime: ${streamLifetimeMs}ms). For provider-backed models, increase modelProviders[providerId][].generationConfig.streamIdleTimeoutMs; provider configuration takes precedence, so model.generationConfig is ignored for those models. For runtime models, increase model.generationConfig.streamIdleTimeoutMs. Built-in Qwen OAuth models cannot be overridden via settings. Use ${QWEN_STREAM_IDLE_TIMEOUT_MS_ENV} for them or whenever no explicit value is active. Set the active value to 0 to disable it.`
     );
     this.idleMs = idleMs;
     this.chunksReceived = chunksReceived;
@@ -1617,6 +1658,9 @@ var ContentGenerationPipeline = class {
       if (isDeepSeekHostname(this.contentGeneratorConfig)) {
         typed2["thinking"] = { type: "disabled" };
       }
+      if (!thinkingMandatory && isOpenRouterHostname(this.contentGeneratorConfig)) {
+        typed2["reasoning"] = { enabled: false };
+      }
     }
     if (thinkingMandatory) {
       const typed2 = providerRequest;
@@ -1939,25 +1983,6 @@ var OpenAIContentGenerator = class {
   async generateContentStream(request, userPromptId) {
     return this.pipeline.executeStream(request, userPromptId);
   }
-  async countTokens(request) {
-    try {
-      const estimator = new RequestTokenizer();
-      const result = await estimator.calculateTokens(request);
-      return {
-        totalTokens: result.totalTokens
-      };
-    } catch (error) {
-      debugLogger5.warn(
-        "Failed to calculate tokens with new tokenizer, falling back to simple method:",
-        error
-      );
-      const content = JSON.stringify(request.contents);
-      const totalTokens = Math.ceil(content.length / 4);
-      return {
-        totalTokens
-      };
-    }
-  }
   async embedContent(request) {
     let text = "";
     if (Array.isArray(request.contents)) {
@@ -2000,9 +2025,6 @@ var OpenAIContentGenerator = class {
       );
     }
   }
-  useSummarizedThinking() {
-    return false;
-  }
 };
 
 // packages/core/src/core/openaiContentGenerator/index.ts

package/chunks/{chunk-7DYNJFES.js → chunk-JB4JIVTJ.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   AuthType
-} from "./chunk-2E3V7G6Y.js";
+} from "./chunk-PPKZ7JOE.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -13,6 +13,10 @@ import {
 // packages/core/src/utils/runtimeModelPrefix.ts
 init_esbuild_shims();
 var RUNTIME_SNAPSHOT_PREFIX = "$runtime|";
+function buildRuntimeSnapshotId(authType, modelId) {
+  return `${RUNTIME_SNAPSHOT_PREFIX}${authType}|${modelId}`;
+}
+__name(buildRuntimeSnapshotId, "buildRuntimeSnapshotId");
 function stripRuntimeSnapshotPrefix(modelId) {
   let id = modelId;
   while (id.startsWith(RUNTIME_SNAPSHOT_PREFIX)) {
@@ -110,6 +114,7 @@ __name(resolveModelIdSelector, "resolveModelIdSelector");
 
 export {
   RUNTIME_SNAPSHOT_PREFIX,
+  buildRuntimeSnapshotId,
   stripRuntimeSnapshotPrefix,
   resolveModelId,
   buildModelIdContext