@qwen-code/qwen-code 0.21.5 → 0.21.6-nightly.20260806.cb3dc107f

package/chunks/{chunk-PDDYAXL2.js → chunk-UGTWD35F.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   SkillError
-} from "./chunk-MISUEWB4.js";
+} from "./chunk-4S4OEQ6U.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";
@@ -90,6 +90,9 @@ var SERVE_CONTROL_EXT_METHODS = {
   sessionTitle: "qwen/control/session/title",
   sessionParent: "qwen/control/session/parent",
   sessionSource: "qwen/control/session/source",
+  sessionLiveConversation: "qwen/control/session/live-conversation",
+  sessionLiveTranscript: "qwen/control/session/live-transcript",
+  sessionBackgroundNotification: "qwen/control/session/background_notification",
   sessionArtifactsPersist: "qwen/control/session/artifacts/persist",
   workspaceMcpRestart: "qwen/control/workspace/mcp/restart",
   workspaceMcpManage: "qwen/control/workspace/mcp/manage",
@@ -130,6 +133,13 @@ var SERVE_CONTROL_EXT_METHODS = {
    * result: `{ payload }`.
    */
   clientMcpMessage: "qwen/control/client_mcp/message",
+  /**
+   * Called by a private ACP CHILD immediately before a tool executor. The
+   * parent validates the runtime-owned session/prompt identity, invokes its
+   * configured external provider once, and returns allow/deny. Unavailable
+   * unless the daemon explicitly enabled required external guarding.
+   */
+  externalToolGuardPrepare: "qwen/control/external_tool_guard/prepare",
   sessionCd: "qwen/control/session/cd",
   /**
    * Also called by the CHILD UP into the parent (like `clientMcpMessage`): the
@@ -140,6 +150,9 @@ var SERVE_CONTROL_EXT_METHODS = {
    * `first-turn` mode, which waits for the sub-session's first turn to finish).
    */
   createSubSession: "qwen/control/create-sub-session",
+  liveCaptureScreenContext: "qwen/control/live/capture-screen-context",
+  liveTaskTool: "qwen/control/live/task-tool",
+  liveSpeakToUser: "qwen/control/live/speak-to-user",
   channelDelivery: "qwen/control/channel-delivery"
 };
 var IDLE_HOOK_EVENTS = {

package/chunks/{chunk-IWGMDSC3.js → chunk-UXWEOM4U.js}

@@ -2,18 +2,21 @@
 "use strict";
 import {
   HistoryReplayer
-} from "./chunk-YO4JI7B4.js";
+} from "./chunk-3IVUXQBG.js";
+import {
+  isA2uiToolMeta
+} from "./chunk-DWO5MRNA.js";
 import {
   ChannelDeliveryError,
   MAX_CHANNEL_DELIVERY_TEXT_LENGTH
-} from "./chunk-QONSRAEV.js";
+} from "./chunk-YP5KH5Y7.js";
 import {
   redactLogCredentials
 } from "./chunk-M5GB774H.js";
 import {
   getUserSettingsPath,
   loadSettings
-} from "./chunk-RM3F46UT.js";
+} from "./chunk-IT4CNDZX.js";
 import {
   getSystemDefaultsPath,
   getSystemSettingsPath
@@ -21,11 +24,11 @@ import {
 import {
   findEnvFiles,
   preResolveHomeEnvOverrides
-} from "./chunk-LYPXNRBX.js";
+} from "./chunk-TE7P6I5J.js";
 import {
   getResponseText,
   ideContextStore
-} from "./chunk-YLL3SC5S.js";
+} from "./chunk-NSESTZWP.js";
 import {
   MAX_CHANNEL_DELIVERY_NAME_LENGTH,
   MAX_CHANNEL_DELIVERY_TARGET_ID_LENGTH
@@ -44,6 +47,35 @@ import {
   __name
 } from "./chunk-J2S4EL5Y.js";
 
+// packages/cli/src/serve/live/session-source.ts
+init_esbuild_shims();
+var LIVE_SESSION_SOURCE_PREFIX = "realtime_voice:";
+function isReservedLiveSessionSource(source) {
+  return source.sourceType === "default" && source.sourceId?.startsWith(LIVE_SESSION_SOURCE_PREFIX) === true;
+}
+__name(isReservedLiveSessionSource, "isReservedLiveSessionSource");
+function isCompatibleLiveSessionSource(source) {
+  const sourceId = source.sourceId;
+  return isReservedLiveSessionSource(source) && typeof sourceId === "string" && sourceId.length > LIVE_SESSION_SOURCE_PREFIX.length;
+}
+__name(isCompatibleLiveSessionSource, "isCompatibleLiveSessionSource");
+function isStandaloneConversationSessionSource(source) {
+  return source.sourceId === void 0 && (source.sourceType === void 0 || source.sourceType === "default");
+}
+__name(isStandaloneConversationSessionSource, "isStandaloneConversationSessionSource");
+async function readLoadableLiveConversationMetadata(sessionId, readMetadata) {
+  const metadata = await readMetadata(sessionId);
+  if (metadata.parentSessionId === void 0 && (isCompatibleLiveSessionSource(metadata) || isStandaloneConversationSessionSource(metadata))) {
+    return metadata;
+  }
+  if (metadata.parentSessionId === void 0 || metadata.sourceType !== void 0 || metadata.sourceId !== void 0) {
+    return void 0;
+  }
+  const parent = await readMetadata(metadata.parentSessionId);
+  return parent.parentSessionId === void 0 && (isCompatibleLiveSessionSource(parent) || isStandaloneConversationSessionSource(parent)) ? metadata : void 0;
+}
+__name(readLoadableLiveConversationMetadata, "readLoadableLiveConversationMetadata");
+
 // packages/cli/src/runtime/workspace-remember-errors.ts
 init_esbuild_shims();
 var MAX_REMEMBER_ERROR_DETAILS_CHARS = 1e3;
@@ -566,6 +598,305 @@ __name(loadSettingsCached, "loadSettingsCached");
 
 // packages/cli/src/acp-integration/session/history-replay-page.ts
 init_esbuild_shims();
+
+// packages/cli/src/acp-integration/session/acp-tool-result-text-projection.ts
+init_esbuild_shims();
+import { Buffer } from "node:buffer";
+var ACP_TOOL_RESULT_TEXT_JSON_BYTE_BUDGET = 65536;
+var ACP_TOOL_RESULT_TEXT_TRUNCATION_MARKER = "\n[... truncated for ACP transport ...]\n";
+var EMPTY_CONTENT_ARRAY_JSON_BYTES = Buffer.byteLength("[]", "utf8");
+var EMPTY_TEXT_BLOCK_JSON_BYTES = Buffer.byteLength(
+  JSON.stringify(createTextBlock("")),
+  "utf8"
+);
+var JSON_ARRAY_SEPARATOR_BYTES = 1;
+var JSON_STRING_DELIMITER_BYTES = 2;
+var TRUNCATION_MARKER_PAYLOAD_BYTES = jsonStringJsonByteLength(ACP_TOOL_RESULT_TEXT_TRUNCATION_MARKER) - JSON_STRING_DELIMITER_BYTES;
+var MAX_CANONICAL_TEXT_BLOCKS = Math.floor(
+  (ACP_TOOL_RESULT_TEXT_JSON_BYTE_BUDGET - EMPTY_CONTENT_ARRAY_JSON_BYTES + JSON_ARRAY_SEPARATOR_BYTES) / (EMPTY_TEXT_BLOCK_JSON_BYTES + JSON_ARRAY_SEPARATOR_BYTES)
+);
+function createTextBlock(text) {
+  return {
+    type: "content",
+    content: { type: "text", text }
+  };
+}
+__name(createTextBlock, "createTextBlock");
+function isObjectRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+__name(isObjectRecord, "isObjectRecord");
+function hasExactKeys(value, first, second) {
+  const keys = Object.keys(value);
+  return keys.length === 2 && Object.hasOwn(value, first) && Object.hasOwn(value, second);
+}
+__name(hasExactKeys, "hasExactKeys");
+function canonicalTextBlocks(value) {
+  if (!Array.isArray(value)) return void 0;
+  for (const block of value) {
+    if (!isObjectRecord(block) || !hasExactKeys(block, "type", "content") || block["type"] !== "content" || !isObjectRecord(block["content"]) || !hasExactKeys(block["content"], "type", "text") || block["content"]["type"] !== "text" || typeof block["content"]["text"] !== "string") {
+      return void 0;
+    }
+  }
+  return value;
+}
+__name(canonicalTextBlocks, "canonicalTextBlocks");
+function jsonPayloadBytesAt(value, index) {
+  const code = value.charCodeAt(index);
+  if (code === 34 || code === 92) return 2;
+  if (code <= 31) {
+    return code === 8 || code === 9 || code === 10 || code === 12 || code === 13 ? 2 : 6;
+  }
+  if (code <= 127) return 1;
+  if (code <= 2047) return 2;
+  if (code >= 55296 && code <= 56319) {
+    const next = value.charCodeAt(index + 1);
+    return next >= 56320 && next <= 57343 ? 4 : 6;
+  }
+  if (code >= 56320 && code <= 57343) return 6;
+  return 3;
+}
+__name(jsonPayloadBytesAt, "jsonPayloadBytesAt");
+function jsonPayloadWidthAt(value, index) {
+  const code = value.charCodeAt(index);
+  if (code < 55296 || code > 56319) return 1;
+  const next = value.charCodeAt(index + 1);
+  return next >= 56320 && next <= 57343 ? 2 : 1;
+}
+__name(jsonPayloadWidthAt, "jsonPayloadWidthAt");
+function jsonStringPayloadByteLength(value, stopAfterBytes = Number.POSITIVE_INFINITY) {
+  let bytes = 0;
+  for (let index = 0; index < value.length; ) {
+    bytes += jsonPayloadBytesAt(value, index);
+    if (bytes > stopAfterBytes) return bytes;
+    index += jsonPayloadWidthAt(value, index);
+  }
+  return bytes;
+}
+__name(jsonStringPayloadByteLength, "jsonStringPayloadByteLength");
+function jsonStringJsonByteLength(value) {
+  return JSON_STRING_DELIMITER_BYTES + jsonStringPayloadByteLength(value);
+}
+__name(jsonStringJsonByteLength, "jsonStringJsonByteLength");
+function jsonPayloadWidthBefore(value, end) {
+  const last = value.charCodeAt(end - 1);
+  if (last >= 56320 && last <= 57343 && end >= 2) {
+    const previous = value.charCodeAt(end - 2);
+    if (previous >= 55296 && previous <= 56319) return 2;
+  }
+  return 1;
+}
+__name(jsonPayloadWidthBefore, "jsonPayloadWidthBefore");
+function selectPrefix(value, budget) {
+  let end = 0;
+  let bytes = 0;
+  while (end < value.length) {
+    const partBytes = jsonPayloadBytesAt(value, end);
+    if (bytes + partBytes > budget) break;
+    bytes += partBytes;
+    end += jsonPayloadWidthAt(value, end);
+  }
+  return end;
+}
+__name(selectPrefix, "selectPrefix");
+function selectSuffix(value, budget) {
+  let start = value.length;
+  let bytes = 0;
+  while (start > 0) {
+    const partWidth = jsonPayloadWidthBefore(value, start);
+    const partBytes = jsonPayloadBytesAt(value, start - partWidth);
+    if (bytes + partBytes > budget) break;
+    bytes += partBytes;
+    start -= partWidth;
+  }
+  return start;
+}
+__name(selectSuffix, "selectSuffix");
+function copyString(value) {
+  return value.split("").join("");
+}
+__name(copyString, "copyString");
+function truncateStringPayload(value, originalPayloadBytes, payloadBudget) {
+  if (originalPayloadBytes <= payloadBudget) return value;
+  if (payloadBudget < TRUNCATION_MARKER_PAYLOAD_BYTES) {
+    return copyString(value.slice(0, selectPrefix(value, payloadBudget)));
+  }
+  const sourceBudget = payloadBudget - TRUNCATION_MARKER_PAYLOAD_BYTES;
+  const headBudget = Math.floor(sourceBudget * 0.2);
+  const tailBudget = sourceBudget - headBudget;
+  const headEnd = selectPrefix(value, headBudget);
+  const tailStart = selectSuffix(value, tailBudget);
+  return copyString(value.slice(0, headEnd)) + ACP_TOOL_RESULT_TEXT_TRUNCATION_MARKER + copyString(value.slice(tailStart));
+}
+__name(truncateStringPayload, "truncateStringPayload");
+function contentSkeletonBytes(blockCount) {
+  if (blockCount === 0) return EMPTY_CONTENT_ARRAY_JSON_BYTES;
+  return EMPTY_CONTENT_ARRAY_JSON_BYTES + blockCount * EMPTY_TEXT_BLOCK_JSON_BYTES + (blockCount - 1) * JSON_ARRAY_SEPARATOR_BYTES;
+}
+__name(contentSkeletonBytes, "contentSkeletonBytes");
+function fallbackContent() {
+  return [createTextBlock(ACP_TOOL_RESULT_TEXT_TRUNCATION_MARKER)];
+}
+__name(fallbackContent, "fallbackContent");
+function jsonByteLength(value) {
+  return Buffer.byteLength(JSON.stringify(value), "utf8");
+}
+__name(jsonByteLength, "jsonByteLength");
+function allocatePayloadBudgets(payloadBytes, availableBytes) {
+  const base = payloadBytes.map(
+    (bytes) => Math.min(bytes, TRUNCATION_MARKER_PAYLOAD_BYTES)
+  );
+  let remaining = availableBytes - base.reduce((sum, bytes) => sum + bytes, 0);
+  if (remaining < 0) return void 0;
+  const capacities = payloadBytes.map((bytes, index) => ({
+    index,
+    capacity: bytes - base[index]
+  }));
+  const sorted = capacities.filter(({ capacity }) => capacity > 0).sort(
+    (left, right) => left.capacity === right.capacity ? left.index - right.index : left.capacity - right.capacity
+  );
+  let active = sorted.length;
+  let position = 0;
+  let level = 0;
+  let remainder = 0;
+  while (position < sorted.length && active > 0 && remaining > 0) {
+    const nextLevel = sorted[position].capacity;
+    const cost = (nextLevel - level) * active;
+    if (cost > remaining) {
+      level += Math.floor(remaining / active);
+      remainder = remaining % active;
+      remaining = 0;
+      break;
+    }
+    level = nextLevel;
+    remaining -= cost;
+    while (position < sorted.length && sorted[position].capacity === nextLevel) {
+      position++;
+      active--;
+    }
+  }
+  const allocations = base.map(
+    (bytes, index) => bytes + Math.min(capacities[index].capacity, level)
+  );
+  if (remainder > 0) {
+    for (const { index, capacity } of capacities) {
+      if (remainder === 0) break;
+      if (capacity > level) {
+        allocations[index]++;
+        remainder--;
+      }
+    }
+  }
+  return allocations;
+}
+__name(allocatePayloadBudgets, "allocatePayloadBudgets");
+function projectContent(original) {
+  if (original.length > MAX_CANONICAL_TEXT_BLOCKS) return fallbackContent();
+  const skeletonBytes = contentSkeletonBytes(original.length);
+  const availablePayloadBytes = ACP_TOOL_RESULT_TEXT_JSON_BYTE_BUDGET - skeletonBytes;
+  let remainingPayloadBytes = availablePayloadBytes;
+  let needsProjection = false;
+  for (const block of original) {
+    const payloadBytes2 = jsonStringPayloadByteLength(
+      block.content.text,
+      remainingPayloadBytes
+    );
+    if (payloadBytes2 > remainingPayloadBytes) {
+      needsProjection = true;
+      break;
+    }
+    remainingPayloadBytes -= payloadBytes2;
+  }
+  if (!needsProjection) return original;
+  const baseScans = original.map(
+    (block) => jsonStringPayloadByteLength(
+      block.content.text,
+      TRUNCATION_MARKER_PAYLOAD_BYTES
+    )
+  );
+  const basePayloadBytes = baseScans.map(
+    (bytes) => Math.min(bytes, TRUNCATION_MARKER_PAYLOAD_BYTES)
+  );
+  const baseTotal = basePayloadBytes.reduce((sum, bytes) => sum + bytes, 0);
+  if (baseTotal > availablePayloadBytes) return fallbackContent();
+  const payloadBytes = original.map((block, index) => {
+    if (baseScans[index] <= TRUNCATION_MARKER_PAYLOAD_BYTES) {
+      return baseScans[index];
+    }
+    const maximumAllocation = availablePayloadBytes - baseTotal + basePayloadBytes[index];
+    const bytes = jsonStringPayloadByteLength(
+      block.content.text,
+      maximumAllocation
+    );
+    return bytes <= maximumAllocation ? bytes : maximumAllocation + 1;
+  });
+  const allocations = allocatePayloadBudgets(
+    payloadBytes,
+    availablePayloadBytes
+  );
+  if (!allocations) return fallbackContent();
+  const projected = original.map((block, index) => {
+    if (payloadBytes[index] <= allocations[index]) return block;
+    return createTextBlock(
+      truncateStringPayload(
+        block.content.text,
+        payloadBytes[index],
+        allocations[index]
+      )
+    );
+  });
+  return jsonByteLength(projected) <= ACP_TOOL_RESULT_TEXT_JSON_BYTE_BUDGET ? projected : fallbackContent();
+}
+__name(projectContent, "projectContent");
+function projectRawOutput(value) {
+  const payloadBudget = ACP_TOOL_RESULT_TEXT_JSON_BYTE_BUDGET - JSON_STRING_DELIMITER_BYTES;
+  const payloadBytes = jsonStringPayloadByteLength(value, payloadBudget);
+  if (payloadBytes <= payloadBudget) return value;
+  const projected = truncateStringPayload(value, payloadBytes, payloadBudget);
+  return jsonByteLength(projected) <= ACP_TOOL_RESULT_TEXT_JSON_BYTE_BUDGET ? projected : ACP_TOOL_RESULT_TEXT_TRUNCATION_MARKER;
+}
+__name(projectRawOutput, "projectRawOutput");
+function a2uiMeta(meta) {
+  if (!meta) return void 0;
+  const toolName = typeof meta["toolName"] === "string" ? meta["toolName"] : void 0;
+  const serverId = typeof meta["serverId"] === "string" ? meta["serverId"] : void 0;
+  return toolName === void 0 && serverId === void 0 ? void 0 : {
+    ...toolName === void 0 ? {} : { toolName },
+    ...serverId === void 0 ? {} : { serverId }
+  };
+}
+__name(a2uiMeta, "a2uiMeta");
+function projectAcpToolResultUpdate(update) {
+  const record = update;
+  if (record["sessionUpdate"] !== "tool_call_update") return update;
+  const meta = isObjectRecord(record["_meta"]) ? record["_meta"] : void 0;
+  if (isA2uiToolMeta(a2uiMeta(meta))) return update;
+  const content = canonicalTextBlocks(record["content"]);
+  const rawOutput = record["rawOutput"];
+  if (content?.length === 1 && typeof rawOutput === "string" && rawOutput === content[0].content.text) {
+    const projectedContent2 = projectContent(content);
+    if (projectedContent2 === content) return update;
+    const projectedText = projectedContent2[0].content.text;
+    return {
+      ...record,
+      content: projectedContent2,
+      rawOutput: projectedText
+    };
+  }
+  const projectedContent = content ? projectContent(content) : void 0;
+  const projectedRawOutput = typeof rawOutput === "string" ? projectRawOutput(rawOutput) : void 0;
+  const contentChanged = projectedContent !== void 0 && projectedContent !== content;
+  const rawOutputChanged = projectedRawOutput !== void 0 && projectedRawOutput !== rawOutput;
+  if (!contentChanged && !rawOutputChanged) return update;
+  return {
+    ...record,
+    ...contentChanged ? { content: projectedContent } : {},
+    ...rawOutputChanged ? { rawOutput: projectedRawOutput } : {}
+  };
+}
+__name(projectAcpToolResultUpdate, "projectAcpToolResultUpdate");
+
+// packages/cli/src/acp-integration/session/history-replay-page.ts
 function createReplayCumulativeUsage() {
   return {
     promptTokens: 0,
@@ -582,27 +913,27 @@ function copyCumulativeUsage(target, source) {
   target.apiTimeMs = source.apiTimeMs;
 }
 __name(copyCumulativeUsage, "copyCumulativeUsage");
-function isObjectRecord(value) {
+function isObjectRecord2(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value);
 }
-__name(isObjectRecord, "isObjectRecord");
+__name(isObjectRecord2, "isObjectRecord");
 function isCumulativeUsage(value) {
-  if (!isObjectRecord(value)) return false;
+  if (!isObjectRecord2(value)) return false;
   return typeof value["promptTokens"] === "number" && Number.isFinite(value["promptTokens"]) && typeof value["cachedTokens"] === "number" && Number.isFinite(value["cachedTokens"]) && typeof value["candidateTokens"] === "number" && Number.isFinite(value["candidateTokens"]) && typeof value["apiTimeMs"] === "number" && Number.isFinite(value["apiTimeMs"]);
 }
 __name(isCumulativeUsage, "isCumulativeUsage");
 function isPendingReplayToolCall(value) {
-  if (!isObjectRecord(value)) return false;
+  if (!isObjectRecord2(value)) return false;
   return typeof value["callId"] === "string" && typeof value["toolName"] === "string" && (value["timestamp"] === void 0 || typeof value["timestamp"] === "string") && typeof value["recordId"] === "string";
 }
 __name(isPendingReplayToolCall, "isPendingReplayToolCall");
 function isCurrentPendingReplayToolCall(value) {
-  if (!isObjectRecord(value)) return false;
+  if (!isObjectRecord2(value)) return false;
   return typeof value["callId"] === "string" && typeof value["toolName"] === "string" && typeof value["sourceRecordId"] === "string" && (value["sourceTimestamp"] === void 0 || typeof value["sourceTimestamp"] === "string");
 }
 __name(isCurrentPendingReplayToolCall, "isCurrentPendingReplayToolCall");
 function parseTranscriptReplayState(replay, logger) {
-  if (!isObjectRecord(replay)) {
+  if (!isObjectRecord2(replay)) {
     return {
       pendingToolCalls: [],
       cumulativeUsage: createReplayCumulativeUsage()
@@ -650,12 +981,13 @@ function replayContext(sessionId, updates, cumulativeUsage, config) {
   return {
     sessionId,
     sendUpdate: /* @__PURE__ */ __name(async (update) => {
+      const projectedUpdate = projectAcpToolResultUpdate(update);
       if (activeRecordId === null) {
-        updates.push(update);
+        updates.push(projectedUpdate);
         return;
       }
-      const record = update;
-      const meta = isObjectRecord(record["_meta"]) ? record["_meta"] : {};
+      const record = projectedUpdate;
+      const meta = isObjectRecord2(record["_meta"]) ? record["_meta"] : {};
       updates.push({
         ...record,
         _meta: { ...meta, "qwen.session.recordId": activeRecordId }
@@ -701,7 +1033,7 @@ function liftSessionUpdateTimestamps(updates) {
   return updates.map((update) => {
     const record = update;
     const meta = record["_meta"];
-    const timestamp = isObjectRecord(meta) ? meta["timestamp"] : void 0;
+    const timestamp = isObjectRecord2(meta) ? meta["timestamp"] : void 0;
     return typeof timestamp === "number" || typeof timestamp === "string" ? { ...record, timestamp } : update;
   });
 }
@@ -711,7 +1043,8 @@ async function replayTranscriptRecordPage({
   page,
   config,
   encodeCursor,
-  logger
+  logger,
+  finalizeDangling = true
 }) {
   const state = parseTranscriptReplayState(page.replay, logger);
   const updates = [];
@@ -723,7 +1056,7 @@ async function replayTranscriptRecordPage({
   try {
     const replayPageState = await replayer.replayPage(page.records, {
       pendingToolCalls: page.direction === "backward" ? [] : state.pendingToolCalls,
-      finalizeDangling: page.direction === "backward" || !page.hasMore,
+      finalizeDangling: finalizeDangling && (page.direction === "backward" || !page.hasMore),
       gaps: page.gaps,
       ...state.goalState ? { goalState: state.goalState } : {}
     });
@@ -822,6 +1155,10 @@ function normalizeChannelDelivery(deliveryId, delivery, text) {
 __name(normalizeChannelDelivery, "normalizeChannelDelivery");
 
 export {
+  LIVE_SESSION_SOURCE_PREFIX,
+  isReservedLiveSessionSource,
+  isCompatibleLiveSessionSource,
+  readLoadableLiveConversationMetadata,
   createWorkspaceMemoryExtractionErrorLogger,
   extractRememberErrorCode,
   workspaceMemoryFailureCode,
@@ -843,6 +1180,7 @@ export {
   parseChannelDelivery,
   normalizeChannelDeliveryText,
   normalizeChannelDelivery,
+  projectAcpToolResultUpdate,
   createReplayCumulativeUsage,
   copyCumulativeUsage,
   collectHistoryReplayUpdates,

package/chunks/{chunk-WU5NBSLD.js → chunk-VRAPDAZM.js}

@@ -3,13 +3,13 @@
 import {
   resolveModelConfig,
   resolveProviderProtocol
-} from "./chunk-YLL3SC5S.js";
+} from "./chunk-NSESTZWP.js";
 import {
   external_exports
 } from "./chunk-H6XPXXMH.js";
 import {
   stripRuntimeSnapshotPrefix
-} from "./chunk-7W5KOBYU.js";
+} from "./chunk-GQMVWRDJ.js";
 import {
   REASONING_EFFORT_TIERS,
   normalizeReasoningEffort
@@ -17,7 +17,7 @@ import {
 import {
   AuthType,
   MODEL_GENERATION_CONFIG_FIELDS
-} from "./chunk-XD2PNH3K.js";
+} from "./chunk-4MBOMW76.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-M744OFVE.js → chunk-W7U4ESW2.js}

@@ -2,7 +2,7 @@
 "use strict";
 import {
   CHANNEL_STARTUP_PROFILE_VERSION
-} from "./chunk-UKZEXS6K.js";
+} from "./chunk-R574ATRM.js";
 import {
   init_esbuild_shims
 } from "./chunk-5O2XNYP6.js";

package/chunks/{chunk-GTM6IHBB.js → chunk-WO2B5E5B.js}

@@ -614,6 +614,7 @@ async function openVoiceStreamWithRetry(open, opts = {}) {
 __name(openVoiceStreamWithRetry, "openVoiceStreamWithRetry");
 
 export {
+  deriveWebSocketBase,
   openVoiceStream,
   openQwenAsrRealtimeStream,
   openVoiceStreamWithRetry

package/chunks/chunk-WOJZWRAZ.js

@@ -0,0 +1,123 @@
+// Force strict mode and setup for ESM
+"use strict";
+import {
+  normalize
+} from "./chunk-ZBVS26BY.js";
+import {
+  init_esbuild_shims
+} from "./chunk-5O2XNYP6.js";
+import {
+  __name
+} from "./chunk-J2S4EL5Y.js";
+
+// packages/core/src/core/modalityDefaults.ts
+init_esbuild_shims();
+var FULL_MULTIMODAL = {
+  image: true,
+  pdf: true,
+  audio: true,
+  video: true
+};
+var MODALITY_PATTERNS = [
+  // -------------------
+  // Google Gemini — full multimodal
+  // -------------------
+  [/^gemini-3/, FULL_MULTIMODAL],
+  [/^gemini-/, FULL_MULTIMODAL],
+  // -------------------
+  // OpenAI — image by default for all gpt/o-series models
+  // -------------------
+  [/^gpt-5/, { image: true }],
+  [/^gpt-/, { image: true }],
+  [/^o\d/, { image: true }],
+  // -------------------
+  // Anthropic Claude — image + pdf
+  // -------------------
+  [/^claude-/, { image: true, pdf: true }],
+  // -------------------
+  // Alibaba / Qwen
+  // -------------------
+  // Qwen Plus models: image + video support
+  [/^qwen3\.5-plus/, { image: true, video: true }],
+  [/^qwen3\.6-plus/, { image: true, video: true }],
+  [/^qwen3\.7-plus/, { image: true, video: true }],
+  // Qwen Max models (3.8+): image support
+  [/^qwen3\.8-max/, { image: true }],
+  [/^coder-model$/, { image: true, video: true }],
+  // Qwen VL (vision-language) models: image + video
+  [/^qwen-vl-/, { image: true, video: true }],
+  [/^qwen3-vl-/, { image: true, video: true }],
+  // Qwen coder / text models: text-only
+  [/^qwen3-coder-/, {}],
+  // Qwen3.6-35B-A3B (local quant variants) — image + video
+  [/^qwen3\.6-35b/, { image: true, video: true }],
+  [/^qwen/, {}],
+  // -------------------
+  // DeepSeek — text-only
+  // -------------------
+  [/^deepseek/, {}],
+  // -------------------
+  // Zhipu GLM
+  // -------------------
+  [/^glm-4\.5v/, { image: true }],
+  [/^glm-5(?:-|$)/, {}],
+  [/^glm-/, {}],
+  // -------------------
+  // MiniMax — M3 supports image + video input; older models default to text-only
+  // -------------------
+  [/^minimax-m3/i, { image: true, video: true }],
+  [/^minimax-/, {}],
+  // -------------------
+  // Moonshot / Kimi
+  // -------------------
+  [/^kimi-k3/, { image: true, video: true }],
+  [/^kimi-k2\./, { image: true, video: true }],
+  [/^kimi-/, {}],
+  // -------------------
+  // ByteDance Doubao — Seed-series and *-vision / *-vl models accept image
+  // input; other Doubao models (pro / lite / text) are text-only.
+  // (QwenLM/qwen-code#4876)
+  // -------------------
+  // seedance (text→video) and seedream (text→image) are generation models with
+  // text-only input — exclude them before the multimodal Seed chat series.
+  [/^doubao-seed(ance|ream)/, {}],
+  [/^doubao-seed/, { image: true }],
+  [/^doubao-.*(vision|vl)/, { image: true }],
+  [/^doubao/, {}]
+];
+function defaultModalities(model) {
+  const norm = normalize(model);
+  for (const [regex, modalities] of MODALITY_PATTERNS) {
+    if (regex.test(norm)) {
+      return { ...modalities };
+    }
+  }
+  return {};
+}
+__name(defaultModalities, "defaultModalities");
+function isQwenFamilyWireModel(model) {
+  if (!model) {
+    return false;
+  }
+  const normalized = model.toLowerCase();
+  return normalized.startsWith("qwen") || normalized === "coder-model";
+}
+__name(isQwenFamilyWireModel, "isQwenFamilyWireModel");
+function isTieredEffortWireModel(model) {
+  if (!model) {
+    return false;
+  }
+  return model.toLowerCase().startsWith("qwen3.8-max");
+}
+__name(isTieredEffortWireModel, "isTieredEffortWireModel");
+
+export {
+  defaultModalities,
+  isQwenFamilyWireModel,
+  isTieredEffortWireModel
+};
+/**
+ * @license
+ * Copyright 2025 Qwen Team
+ * SPDX-License-Identifier: Apache-2.0
+ */