@qwen-code/qwen-code 0.21.0 → 0.21.1-nightly.20260731.702932cc7

package/chunks/chunk-KWHKHSIS.js

@@ -0,0 +1,81 @@
+// 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/commands/channel/channel-registry.ts
+init_esbuild_shims();
+var registry = /* @__PURE__ */ new Map();
+var builtinsPromise = null;
+function ensureBuiltins() {
+  if (!builtinsPromise) {
+    builtinsPromise = (async () => {
+      const labelled = [
+        { name: "telegram", promise: import("./dist-ZHXOBXDN.js") },
+        { name: "weixin", promise: import("./dist-OAOC5OV4.js") },
+        { name: "dingtalk", promise: import("./dist-SL2LUMML.js") },
+        { name: "wecom", promise: import("./dist-PVEAFLHY.js") },
+        { name: "feishu", promise: import("./dist-2PERFI23.js") },
+        { name: "qqbot", promise: import("./dist-WGMNT3JQ.js") },
+        { name: "github", promise: import("./dist-26BIMQT6.js") },
+        { name: "gitlab", promise: import("./dist-ULIG4M5H.js") }
+      ];
+      const results = await Promise.allSettled(labelled.map((l) => l.promise));
+      for (let i = 0; i < results.length; i++) {
+        const result = results[i];
+        if (result.status === "fulfilled") {
+          registry.set(result.value.plugin.channelType, result.value.plugin);
+        } else {
+          process.stderr.write(
+            `[channel-registry] Failed to load "${labelled[i].name}" channel: ${result.reason}
+`
+          );
+        }
+      }
+    })();
+  }
+  return builtinsPromise;
+}
+__name(ensureBuiltins, "ensureBuiltins");
+function registerPlugin(plugin) {
+  if (registry.has(plugin.channelType)) {
+    throw new Error(
+      `Channel type "${plugin.channelType}" is already registered.`
+    );
+  }
+  registry.set(plugin.channelType, plugin);
+}
+__name(registerPlugin, "registerPlugin");
+async function getPlugin(channelType) {
+  await ensureBuiltins();
+  return registry.get(channelType);
+}
+__name(getPlugin, "getPlugin");
+async function supportedTypes() {
+  await ensureBuiltins();
+  return [...registry.keys()];
+}
+__name(supportedTypes, "supportedTypes");
+async function supportedChannelCatalog() {
+  await ensureBuiltins();
+  return [...registry.values()].map(
+    ({ channelType, displayName, management }) => ({
+      type: channelType,
+      displayName,
+      manageable: management !== void 0,
+      fields: management?.fields ?? []
+    })
+  );
+}
+__name(supportedChannelCatalog, "supportedChannelCatalog");
+
+export {
+  registerPlugin,
+  getPlugin,
+  supportedTypes,
+  supportedChannelCatalog
+};

package/chunks/{chunk-DHHOYAPR.js → chunk-L2E5GFAG.js}

@@ -3,16 +3,16 @@
 import {
   InvalidStreamError,
   createOpenAIReasoningThoughtPart
-} from "./chunk-BPJSQIJX.js";
+} from "./chunk-2J3OJGTL.js";
 import {
   convertSchema,
   relaxSchemaForFunctionCalling,
   safeJsonParse,
   setGenAiUsageProvenance
-} from "./chunk-H5FFA6TH.js";
+} from "./chunk-QTHQ6Z5X.js";
 import {
   setToolCallPreparations
-} from "./chunk-LS77BEZP.js";
+} from "./chunk-GLCZKT5V.js";
 import {
   TOKEN_ESTIMATE_UNITS_PER_TOKEN,
   estimateTextTokenUnits,
@@ -21,7 +21,7 @@ import {
 } from "./chunk-46UV252V.js";
 import {
   createDebugLogger
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   FinishReason,
   GenerateContentResponse
@@ -202,7 +202,9 @@ function convertGeminiToolParametersToOpenAI(parameters) {
     }
     const result = {};
     for (const [key, value] of Object.entries(obj)) {
-      if (key === "type" && typeof value === "string") {
+      if (typeof value === "object" && value !== null) {
+        result[key] = convertTypes(value);
+      } else if (key === "type" && typeof value === "string") {
         const lowerValue = value.toLowerCase();
         if (lowerValue === "integer") {
           result[key] = "integer";
@@ -224,8 +226,6 @@ function convertGeminiToolParametersToOpenAI(parameters) {
         } else {
           result[key] = value;
         }
-      } else if (typeof value === "object") {
-        result[key] = convertTypes(value);
       } else {
         result[key] = value;
       }

package/chunks/{chunk-2W3OOD4W.js → chunk-L55JWS76.js}

@@ -9,16 +9,19 @@ import {
 
 // packages/cli/src/serve/workspace-skills-mapping.ts
 init_esbuild_shims();
-function mapSkillConfigToStatus(skill, disabledSkillNames = /* @__PURE__ */ new Set(), opts = {}) {
-  const userDisabled = disabledSkillNames.has(skill.name.toLowerCase());
+function mapSkillConfigToStatus(skill, disablements = /* @__PURE__ */ new Map(), opts = {}) {
+  const disablement = disablements.get(skill.name.toLowerCase());
+  const disabledReason = opts.disabled ? "inactive_extension" : disablement?.reason;
   const modelInvocable = skill.disableModelInvocation !== true;
   return {
     kind: "skill",
-    status: opts.disabled || userDisabled ? "disabled" : "ok",
+    status: disabledReason ? "disabled" : "ok",
     name: skill.name,
     description: skill.description,
     level: skill.level,
     modelInvocable,
+    ...disabledReason ? { disabledReason } : {},
+    ...!opts.disabled && disablement?.lockedScope ? { lockedScope: disablement.lockedScope } : {},
     ...skill.userInvocable === false ? { userInvocable: false } : {},
     installedPath: skill.filePath,
     ...skill.argumentHint ? { argumentHint: skill.argumentHint } : {},

package/chunks/{chunk-E5TUC6CA.js → chunk-LHKCY7DY.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   isPrivateHost
-} from "./chunk-NH6KE4JX.js";
+} from "./chunk-LOY7RWQG.js";
 import {
   loadUndici
-} from "./chunk-2JZBVYTU.js";
+} from "./chunk-Q3T5KA2V.js";
 import {
   getErrorMessage
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-NH6KE4JX.js → chunk-LOY7RWQG.js}

@@ -2,13 +2,13 @@
 "use strict";
 import {
   delay
-} from "./chunk-USTWD7QV.js";
+} from "./chunk-E6CJ2SMM.js";
 import {
   isTlsVerificationDisabled
-} from "./chunk-2JZBVYTU.js";
+} from "./chunk-Q3T5KA2V.js";
 import {
   getErrorMessage
-} from "./chunk-NL7LTRLR.js";
+} from "./chunk-E2BHWIDT.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-U7M2DMGW.js → chunk-M4MSAE7U.js}

@@ -2,15 +2,15 @@
 "use strict";
 import {
   sanitizeFilenameForDisplay
-} from "./chunk-IPUUTYMV.js";
+} from "./chunk-YDLJGZHL.js";
 import {
   t
-} from "./chunk-LKEJ26GS.js";
+} from "./chunk-B3TA3IF5.js";
 import {
   fetchGitDiff,
   findProviderByCredentials,
   resolveMetadataKey
-} from "./chunk-PHOF65IG.js";
+} from "./chunk-FRXG4ARO.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -274,6 +274,115 @@ var diffCommand = {
   action: diffAction
 };
 
+// packages/cli/src/ui/utils/inline-math.ts
+init_esbuild_shims();
+var INLINE_MATH_MAX_CHARS = 1024;
+var INLINE_CODE_SPAN_PATTERN_SOURCE = String.raw`(?<!\`)(?<inlineCodeFence>\`+)(?!\`).+?(?<!\`)\k<inlineCodeFence>(?!\`)`;
+var INLINE_CODE_SPAN_RE = new RegExp(INLINE_CODE_SPAN_PATTERN_SOURCE, "g");
+function isEscapedAt(text, index) {
+  let slashCount = 0;
+  for (let cursor = index - 1; cursor >= 0 && text[cursor] === "\\"; cursor -= 1) {
+    slashCount += 1;
+  }
+  return slashCount % 2 === 1;
+}
+__name(isEscapedAt, "isEscapedAt");
+function isUnescapedDollarAt(text, index) {
+  return text[index] === "$" && !isEscapedAt(text, index);
+}
+__name(isUnescapedDollarAt, "isUnescapedDollarAt");
+function unescapeMarkdownDollars(text) {
+  return text.replace(
+    /(\\+)\$/g,
+    (_match, slashes) => `${"\\".repeat(Math.floor(slashes.length / 2))}$`
+  );
+}
+__name(unescapeMarkdownDollars, "unescapeMarkdownDollars");
+function unescapeMarkdownBeforeMath(text) {
+  return unescapeMarkdownDollars(`${text}$`).slice(0, -1);
+}
+__name(unescapeMarkdownBeforeMath, "unescapeMarkdownBeforeMath");
+function readInlineMathSpan(text, index) {
+  if (!isUnescapedDollarAt(text, index)) {
+    return null;
+  }
+  const previous = text[index - 1] ?? "";
+  const next = text[index + 1] ?? "";
+  if (/\w/.test(previous) || isUnescapedDollarAt(text, index - 1) || !next || /[\s\d$]/.test(next)) {
+    return null;
+  }
+  let closingIndex = index + 1;
+  while (closingIndex < text.length && text[closingIndex] !== "\n" && closingIndex - index - 1 <= INLINE_MATH_MAX_CHARS && !isUnescapedDollarAt(text, closingIndex)) {
+    closingIndex += 1;
+  }
+  if (!isUnescapedDollarAt(text, closingIndex)) {
+    return null;
+  }
+  const content = text.slice(index + 1, closingIndex);
+  const following = text[closingIndex + 1] ?? "";
+  if (content.length > INLINE_MATH_MAX_CHARS || /\s$/.test(content) || /[\w$]/.test(following)) {
+    return null;
+  }
+  return {
+    content,
+    index,
+    raw: text.slice(index, closingIndex + 1)
+  };
+}
+__name(readInlineMathSpan, "readInlineMathSpan");
+function findNextInlineMath(text, fromIndex = 0) {
+  for (let index = fromIndex; index < text.length; index += 1) {
+    const span = readInlineMathSpan(text, index);
+    if (span) {
+      return span;
+    }
+  }
+  return null;
+}
+__name(findNextInlineMath, "findNextInlineMath");
+function* mergeInlineMathMatches(text, markupRegex, enableInlineMath = true) {
+  markupRegex.lastIndex = 0;
+  const markupMatches = text.matchAll(markupRegex);
+  let nextMarkup = markupMatches.next();
+  let nextMath = enableInlineMath ? findNextInlineMath(text) : null;
+  let cursor = 0;
+  while (!nextMarkup.done || nextMath) {
+    while (!nextMarkup.done && (nextMarkup.value.index ?? 0) < cursor) {
+      nextMarkup = markupMatches.next();
+    }
+    if (nextMath && nextMath.index < cursor) {
+      nextMath = findNextInlineMath(text, cursor);
+    }
+    const markupIndex = nextMarkup.done ? Number.POSITIVE_INFINITY : nextMarkup.value.index ?? 0;
+    const mathIndex = nextMath?.index ?? Number.POSITIVE_INFINITY;
+    if (!nextMarkup.done && markupIndex <= mathIndex) {
+      const match = nextMarkup.value;
+      yield { kind: "markup", match };
+      cursor = markupIndex + match[0].length;
+      nextMarkup = markupMatches.next();
+    } else if (nextMath) {
+      yield { kind: "math", span: nextMath };
+      cursor = mathIndex + nextMath.raw.length;
+      nextMath = findNextInlineMath(text, cursor);
+    }
+  }
+}
+__name(mergeInlineMathMatches, "mergeInlineMathMatches");
+function findInlineMathExpressions(text) {
+  const expressions = [];
+  for (const token of mergeInlineMathMatches(text, INLINE_CODE_SPAN_RE)) {
+    if (token.kind === "math") {
+      expressions.push(token.span.content);
+    }
+  }
+  return expressions;
+}
+__name(findInlineMathExpressions, "findInlineMathExpressions");
+function readInlineMathSpanAt(text, index) {
+  return readInlineMathSpan(text, index)?.raw ?? null;
+}
+__name(readInlineMathSpanAt, "readInlineMathSpanAt");
+
 // packages/cli/src/utils/systemInfoFields.ts
 init_esbuild_shims();
 function getSystemInfoFields(info) {
@@ -390,10 +499,15 @@ init_esbuild_shims();
 function calculateCost(args) {
   const { inputTokens, outputTokens, pricing } = args;
   if (!pricing) return null;
+  if (pricing.inputPerMillionTokens == null && pricing.outputPerMillionTokens == null) {
+    return null;
+  }
+  if (inputTokens <= 0 && outputTokens <= 0) {
+    return null;
+  }
   const inputCost = pricing.inputPerMillionTokens != null ? inputTokens / 1e6 * pricing.inputPerMillionTokens : 0;
   const outputCost = pricing.outputPerMillionTokens != null ? outputTokens / 1e6 * pricing.outputPerMillionTokens : 0;
-  const total = inputCost + outputCost;
-  return total > 0 ? total : null;
+  return inputCost + outputCost;
 }
 __name(calculateCost, "calculateCost");
 
@@ -418,6 +532,12 @@ function levelLabel(level) {
 __name(levelLabel, "levelLabel");
 
 export {
+  INLINE_CODE_SPAN_PATTERN_SOURCE,
+  unescapeMarkdownDollars,
+  unescapeMarkdownBeforeMath,
+  mergeInlineMathMatches,
+  findInlineMathExpressions,
+  readInlineMathSpanAt,
   getSystemInfoFields,
   calculateErrorRate,
   calculateAverageLatency,
@@ -435,6 +555,11 @@ export {
  * Copyright 2025 Google LLC
  * SPDX-License-Identifier: Apache-2.0
  */
+/**
+ * @license
+ * Copyright 2026 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */
 /**
  * @license
  * Copyright 2025 Qwen

package/chunks/{chunk-IJTOWOD7.js → chunk-MB32MS4U.js}

@@ -3,19 +3,19 @@
 import {
   isLoopbackBind
 } from "./chunk-RXFQM6FQ.js";
-import {
-  CLIENT_MCP_OVER_WS_CONFIG_FLAG
-} from "./chunk-3SJ43L4W.js";
 import {
   require_lib
-} from "./chunk-WBL3FJEU.js";
+} from "./chunk-FC4KQFCS.js";
 import {
-  require_mime_db
-} from "./chunk-T2NCM2ET.js";
+  CLIENT_MCP_OVER_WS_CONFIG_FLAG
+} from "./chunk-CPZAH673.js";
 import {
   MAX_WORKSPACE_PATH_LENGTH,
   translateAndCheckAbsoluteWorkspacePath
 } from "./chunk-2RFKHEXL.js";
+import {
+  require_mime_db
+} from "./chunk-K6KS3LTN.js";
 import {
   writeStderrLine
 } from "./chunk-OWAK7LMW.js";
@@ -16433,6 +16433,8 @@ var ClientMcpSenderRegistry = class {
     __name(this, "ClientMcpSenderRegistry");
   }
   senders = /* @__PURE__ */ new Map();
+  sessionSenders = /* @__PURE__ */ new Map();
+  sessionScopedServerNames = /* @__PURE__ */ new Set();
   /**
    * Record a server's WS sender, owned by `owner` (the registering
    * connection's stable client id). Idempotent; last writer wins and takes
@@ -16455,6 +16457,27 @@ var ClientMcpSenderRegistry = class {
   owns(serverName, owner) {
     return this.senders.get(serverName)?.owner === owner;
   }
+  setSession(serverName, sessionId, sender, owner) {
+    let bySession = this.sessionSenders.get(serverName);
+    if (!bySession) {
+      bySession = /* @__PURE__ */ new Map();
+      this.sessionSenders.set(serverName, bySession);
+    }
+    bySession.set(sessionId, { sender, owner });
+    this.sessionScopedServerNames.add(serverName);
+  }
+  ownsSession(serverName, sessionId, owner) {
+    return this.sessionSenders.get(serverName)?.get(sessionId)?.owner === owner;
+  }
+  deleteSession(serverName, sessionId, owner) {
+    const bySession = this.sessionSenders.get(serverName);
+    if (bySession?.get(sessionId)?.owner !== owner) return false;
+    bySession.delete(sessionId);
+    if (bySession.size === 0) {
+      this.sessionSenders.delete(serverName);
+    }
+    return true;
+  }
   /** Currently-registered server names (tests / accounting). */
   serverNames() {
     return [...this.senders.keys()];
@@ -16468,8 +16491,37 @@ var ClientMcpSenderRegistry = class {
    */
   lookup = /* @__PURE__ */ __name((serverName) => {
     const entry = this.senders.get(serverName);
-    if (!entry) return void 0;
-    return (payload) => entry.sender(serverName, payload);
+    const sessionEntries = this.sessionSenders.get(serverName);
+    if (!entry && !sessionEntries) return void 0;
+    return (payload, context) => {
+      if (context?.sessionId) {
+        const sessionEntry = sessionEntries?.get(context.sessionId);
+        if (sessionEntry) return sessionEntry.sender(payload);
+        if (this.sessionScopedServerNames.has(serverName)) {
+          return Promise.reject(
+            new Error(
+              `No session-scoped MCP sender for '${serverName}' in session '${context.sessionId}'.`
+            )
+          );
+        }
+      }
+      if (this.sessionScopedServerNames.has(serverName)) {
+        return Promise.reject(
+          new Error(
+            `Session-scoped MCP server '${serverName}' requires a session context.`
+          )
+        );
+      }
+      if (!entry) {
+        return Promise.reject(
+          new Error(`No client MCP sender for '${serverName}'.`)
+        );
+      }
+      return entry.sender(
+        serverName,
+        payload
+      );
+    };
   }, "lookup");
 };
 function createClientMcpServerProvider(registry, bridge, originatorClientId) {
@@ -16544,6 +16596,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   // must not be polled in a tight loop.
   session_info: { since: "v1" },
   session_source_metadata: { since: "v1" },
+  session_side_task: { since: "v1" },
   session_prompt: { since: "v1" },
   session_cancel: { since: "v1" },
   session_events: { since: "v1" },
@@ -16593,6 +16646,7 @@ var SERVE_CAPABILITY_REGISTRY = {
   session_context_usage: { since: "v1" },
   session_supported_commands: { since: "v1" },
   session_tasks: { since: "v1" },
+  session_monitor_tool_correlation: { since: "v1" },
   session_stats: { since: "v1" },
   session_lsp: { since: "v1" },
   session_status: { since: "v1" },
@@ -16629,6 +16683,14 @@ var SERVE_CAPABILITY_REGISTRY = {
   // advertise the text/list/stat/glob surface without byte-window
   // support.
   workspace_file_bytes: { since: "v1" },
+  // Daemon supports byte-cursor paging on `GET /file`: responses carry
+  // `nextCursor`/`hasMore` and requests accept `cursor`. A separate tag from
+  // `workspace_file_read` because the convention here is that new behavior
+  // gets a new tag — a client that preflighted the old one must not silently
+  // receive a surface it cannot recognise. Same split as
+  // `workspace_file_bytes` from `workspace_file_read`, and
+  // `session_transcript_pagination` from `session_transcript`.
+  workspace_file_read_cursor: { since: "v1" },
   // Daemon supports hash-aware text mutation routes
   // (`POST /file/write`, `POST /file/edit`) behind the strict mutation
   // gate. Clients should still pre-flight `require_auth` separately for
@@ -16663,6 +16725,9 @@ var SERVE_CAPABILITY_REGISTRY = {
   // Inspect bound workspace trust and request local operator action.
   // Remote clients cannot directly write trustedFolders.json.
   workspace_trust: { since: "v1" },
+  // Workspace trust policy changes rebuild the affected runtime generation
+  // without restarting the daemon. V2 trust status exposes convergence.
+  workspace_trust_hot_reload: { since: "v1" },
   // `POST /workspace/init` scaffolds an empty
   // `QWEN.md` (or whatever `getCurrentGeminiMdFilename()` returns) at
   // the bound workspace root. Body: `{force?: boolean}`. Default
@@ -16676,6 +16741,12 @@ var SERVE_CAPABILITY_REGISTRY = {
   // explicit consent. The route reuses the interactive `/setup-github`
   // release lookup, workflow download, and `.gitignore` update logic.
   workspace_github_setup: { since: "v1" },
+  // `GET /workspaces/:workspace/github/prs` lists the open pull requests
+  // of the workspace's GitHub remote via the `gh` CLI (read-only). The
+  // tag means the route contract exists; runtime availability of `gh`
+  // and its auth is reported per-request through the
+  // `github_cli_unavailable` / `github_prs_failed` error codes.
+  workspace_github_prs: { since: "v1" },
   // `POST /workspace/mcp/:server/restart` performs
   // a single-server MCP restart (disconnect + reconnect + rediscover)
   // through the ACP child's `McpClientManager`. Pre-checks the live
@@ -16788,6 +16859,8 @@ var SERVE_CAPABILITY_REGISTRY = {
   // Runtime GET/PUT/DELETE control for daemon-managed channel selection.
   // The route exists even when no selection was supplied at daemon boot.
   channel_control: { since: "v1" },
+  // Sanitized workspace Channel configuration, lifecycle, and pairing.
+  channel_management: { since: "v1" },
   // Read-only workspace graph of recently observed channel contacts.
   workspace_channel_observed_contacts: { since: "v1" },
   // Multi-workspace session routing. Advertised only when one daemon hosts
@@ -16910,8 +16983,16 @@ var CONDITIONAL_SERVE_FEATURES = /* @__PURE__ */ new Map([
   ],
   ["rate_limit", (toggles) => toggles.rateLimit === true],
   ["workspace_reload", (toggles) => toggles.reloadAvailable === true],
+  [
+    "workspace_trust_hot_reload",
+    (toggles) => toggles.workspaceTrustHotReloadAvailable === true
+  ],
   ["channel_reload", (toggles) => toggles.channelReloadAvailable === true],
   ["channel_control", (toggles) => toggles.channelControlAvailable === true],
+  [
+    "channel_management",
+    (toggles) => toggles.channelManagementAvailable === true
+  ],
   [
     "multi_workspace_sessions",
     (toggles) => toggles.multiWorkspaceSessionsEnabled === true
@@ -17703,6 +17784,8 @@ async function buildDaemonStatusResponse(detail, input) {
       listenerMaxConnections: listenerMaxConnections(input.opts.maxConnections),
       eventRingSize: bridgeSnapshot.limits.eventRingSize,
       compactedReplayMaxBytes: bridgeSnapshot.limits.compactedReplayMaxBytes,
+      maxJournalEvents: bridgeSnapshot.limits.maxJournalEvents,
+      maxJournalBytes: bridgeSnapshot.limits.maxJournalBytes,
       promptDeadlineMs: positiveFiniteOrNull(input.opts.promptDeadlineMs),
       writerIdleTimeoutMs: positiveFiniteOrNull(input.opts.writerIdleTimeoutMs),
       channelIdleTimeoutMs: bridgeSnapshot.limits.channelIdleTimeoutMs,
@@ -18319,7 +18402,7 @@ var WorkspaceVoiceCoordinator = class {
     state.completed = true;
     const abortReason = new VoiceLeaseAbortError(
       reason,
-      reason === "workspace_removed" ? "Workspace runtime was removed" : "Daemon is shutting down"
+      reason === "daemon_shutdown" ? "Daemon is shutting down" : reason === "workspace_removed" ? "Workspace runtime was removed" : "Workspace trust was reconfigured"
     );
     for (const lease of state.leases) lease.abort(abortReason);
     if (state.leases.size === 0) {