@soimy/dingtalk 3.6.2 → 3.6.4

package/dist/index.js

@@ -1814,7 +1814,7 @@ async function updateCardVariables(outTrackId, params, token, config) {
     {
       outTrackId,
       cardData: { cardParamMap: stringMap },
-      cardUpdateOptions: { updateCardDataByKey: true, updatePrivateDataByKey: true }
+      cardUpdateOptions: { updateCardDataByKey: true }
     },
     {
       headers: {
@@ -2614,6 +2614,19 @@ async function createAICard(config, conversationId, log, options = {}) {
       upsertPendingCard(aiCardInstance, options.storePath, log);
     }
     clearAICardDegrade(accountId, log);
+    try {
+      await putAICardStreamingField(aiCardInstance, template.contentKey, "", false, log, {
+        suppressDegrade: true
+      });
+      aiCardInstance.state = AICardStatus.INPUTING;
+      if (shouldPersistPending) {
+        upsertPendingCard(aiCardInstance, options.storePath, log);
+      }
+    } catch (kickErr) {
+      log?.debug?.(
+        `[DingTalk][AICard] Non-critical: failed to kick card into streaming mode: ${kickErr.message}`
+      );
+    }
     return aiCardInstance;
   } catch (err) {
     log?.error?.(`[DingTalk][AICard] Create failed: ${err.message}`);
@@ -2712,13 +2725,13 @@ async function clearAICardStreamingContent(card, log) {
     log?.debug?.(`[DingTalk][AICard] Non-critical: failed to clear streaming content: ${message}`);
   }
 }
-async function finalizeAICardStreamingLifecycleIfNeeded(card, content, log) {
+async function finalizeAICardStreamingLifecycleIfNeeded(card, log) {
   if (!card.streamLifecycleOpened) {
     return;
   }
   const template = DINGTALK_CARD_TEMPLATE;
   try {
-    await putAICardStreamingField(card, template.streamingKey, content, true, log, {
+    await putAICardStreamingField(card, template.streamingKey, "", true, log, {
       suppressDegrade: true
     });
   } catch (err) {
@@ -2734,7 +2747,7 @@ async function commitAICardBlocks(card, options, log) {
     return;
   }
   await ensureFreshToken(card, log);
-  await finalizeAICardStreamingLifecycleIfNeeded(card, options.content, log);
+  await finalizeAICardStreamingLifecycleIfNeeded(card, log);
   const template = DINGTALK_CARD_TEMPLATE;
   const updates = {
     [template.blockListKey]: options.blockListJson,
@@ -2797,7 +2810,7 @@ async function finalizeStoppedAICard(card, options, log) {
   await ensureFreshToken(card, log);
   const template = DINGTALK_CARD_TEMPLATE;
   const payload = buildStoppedCardFinalizePayload(options);
-  await finalizeAICardStreamingLifecycleIfNeeded(card, payload.content, log);
+  await finalizeAICardStreamingLifecycleIfNeeded(card, log);
   try {
     await updateCardVariables(
       card.outTrackId || card.cardInstanceId,
@@ -4475,7 +4488,7 @@ function stripLeadingInvisibleChars(value) {
 
 // src/inbound-handler.ts
 import fs6 from "node:fs";
-import * as path9 from "node:path";
+import * as path10 from "node:path";
 import { isAbortRequestText, isBtwRequestText } from "openclaw/plugin-sdk/reply-runtime";
 import { parseInlineDirectives } from "openclaw/plugin-sdk/text-runtime";
 
@@ -6716,7 +6729,7 @@ function isMarkdownTableSeparator(line) {
     return false;
   }
   const cells = normalized.replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
-  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+  return cells.length > 0 && cells.every((cell) => /^:?-{1,}:?$/.test(cell));
 }
 function isMarkdownTableRow(line) {
   const trimmed = line.trim();
@@ -6725,9 +6738,58 @@ function isMarkdownTableRow(line) {
 function parseMarkdownTableRow(line) {
   return line.trim().replace(/^\|/, "").replace(/\|$/, "").split("|").map((cell) => cell.trim());
 }
-function renderMarkdownTable(lines) {
-  const rows = lines.map(parseMarkdownTableRow).filter((cells) => cells.length > 0);
-  return rows.map((cells) => cells.join(" | ")).join("  \n");
+function parseSeparatorAlignment(cell) {
+  const trimmed = cell.trim();
+  const hasLeftColon = trimmed.startsWith(":");
+  const hasRightColon = trimmed.endsWith(":");
+  if (hasLeftColon && hasRightColon) {
+    return "center";
+  }
+  if (hasRightColon) {
+    return "right";
+  }
+  if (hasLeftColon) {
+    return "left";
+  }
+  return "center";
+}
+function buildSeparatorRow(alignments) {
+  const cells = alignments.map((align) => {
+    if (align === "left") {
+      return ":---";
+    }
+    if (align === "right") {
+      return "---:";
+    }
+    return ":---:";
+  });
+  return "|" + cells.join("|") + "|";
+}
+function renderMarkdownTable(headerLine, separatorLine, dataLines) {
+  const headerCells = parseMarkdownTableRow(headerLine);
+  const separatorCells = parseMarkdownTableRow(separatorLine);
+  const dataRows = dataLines.map(parseMarkdownTableRow).filter((cells) => cells.length > 0);
+  if (headerCells.length === 0) {
+    return "";
+  }
+  const colCount = Math.max(
+    headerCells.length,
+    separatorCells.length,
+    ...dataRows.map((cells) => cells.length)
+  );
+  const alignments = [];
+  for (let i = 0; i < colCount; i++) {
+    const sepCell = separatorCells[i] || "";
+    alignments.push(parseSeparatorAlignment(sepCell));
+  }
+  const separator = buildSeparatorRow(alignments);
+  const allRows = [headerCells, ...dataRows];
+  const rendered = allRows.map((cells) => {
+    const padded = cells.length < colCount ? [...cells, ...Array(colCount - cells.length).fill("")] : cells;
+    return "|" + padded.join("|") + "|";
+  });
+  rendered.splice(1, 0, separator);
+  return rendered.join("\n");
 }
 function convertMarkdownTablesToPlainText(text) {
   const lines = text.split("\n");
@@ -6743,13 +6805,20 @@ function convertMarkdownTablesToPlainText(text) {
       continue;
     }
     if (!inCodeFence && index + 1 < lines.length && isMarkdownTableRow(line) && isMarkdownTableSeparator(lines[index + 1] || "")) {
-      const tableLines = [line];
+      const headerLine = line;
+      const separatorLine = lines[index + 1] || "";
+      const dataLines = [];
       index += 2;
       while (index < lines.length && isMarkdownTableRow(lines[index] || "")) {
-        tableLines.push(lines[index] || "");
+        dataLines.push(lines[index] || "");
         index += 1;
       }
-      output.push(renderMarkdownTable(tableLines));
+      const renderedTable = renderMarkdownTable(headerLine, separatorLine, dataLines);
+      const lastOutput = output[output.length - 1];
+      if (lastOutput !== void 0 && lastOutput.trim() !== "") {
+        output.push("");
+      }
+      output.push(renderedTable);
       continue;
     }
     output.push(line);
@@ -7247,6 +7316,9 @@ function buildPersistedOutboundText(text, options) {
   }
   return text;
 }
+function shouldRouteSessionMediaViaProactive(mediaType) {
+  return mediaType === "voice" || mediaType === "video" || mediaType === "file";
+}
 var DINGTALK_TEXT_CHUNK_LIMIT = 3800;
 var CARD_MEDIA_CONTROLLER_ATTACH_WAIT_MS = 150;
 var CARD_MEDIA_CONTROLLER_ATTACH_POLL_MS = 25;
@@ -7643,51 +7715,33 @@ async function sendBySession(config, sessionWebhook, text, options = {}) {
   const token = await getAccessToken(config, options.log);
   const log = options.log || getLogger();
   if (options.mediaPath && options.mediaType) {
-    const uploadResult = await uploadMedia2(config, options.mediaPath, options.mediaType, log, {
-      mediaLocalRoots: options.mediaLocalRoots
-    });
-    if (uploadResult) {
-      const { mediaId, buffer, durationMs: uploadedDurationMs } = uploadResult;
-      let body;
-      if (options.mediaType === "image") {
-        body = { msgtype: "image", image: { media_id: mediaId } };
-      } else if (options.mediaType === "voice") {
-        const durationMs = uploadedDurationMs ?? await getVoiceDurationMs(options.mediaPath, options.mediaType, log, { preReadBuffer: buffer });
-        body = { msgtype: "voice", voice: { media_id: mediaId, duration: String(durationMs) } };
-        log?.debug?.(
-          `[DingTalk] Sending session voice message mediaId=${mediaId} durationMs=${durationMs}`
-        );
-      } else if (options.mediaType === "video") {
-        body = { msgtype: "video", video: { media_id: mediaId } };
-      } else if (options.mediaType === "file") {
-        body = { msgtype: "file", file: { media_id: mediaId } };
-      }
-      if (body) {
-        const result = await http_client_default({
-          url: sessionWebhook,
-          method: "POST",
-          data: body,
-          headers: { "x-acs-dingtalk-access-token": token, "Content-Type": "application/json" },
-          ...getProxyBypassOption(config)
-        });
+    if (options.mediaType === "image") {
+      const uploadResult = await uploadMedia2(config, options.mediaPath, options.mediaType, log, {
+        mediaLocalRoots: options.mediaLocalRoots
+      });
+      if (uploadResult) {
+        const imageMarkdown = `![${path7.basename(options.mediaPath)}](${uploadResult.mediaId})`;
+        text = text ? `${text}
+
+${imageMarkdown}` : imageMarkdown;
         log?.debug?.(
-          `[DingTalk] Session webhook response msgtype=${body.msgtype} ${summarizeSessionWebhookResponse(result.data)}`
+          `[DingTalk] Session webhook image will be delivered as markdown media reference mediaId=${uploadResult.mediaId}`
         );
-        ensureSessionWebhookBusinessSuccess(result.data, { msgtype: body.msgtype });
-        const delivery = extractOutboundDeliveryMetadata(result.data);
-        if (!delivery.messageId && !delivery.processQueryKey && !delivery.outTrackId) {
-          log?.warn?.(
-            `[DingTalk] Session webhook ${body.msgtype} response missing delivery metadata; ` + summarizeSessionWebhookResponse(result.data)
-          );
-        }
-        return result.data;
+      } else {
+        const mediaHint = options.mediaUrl || options.mediaPath || options.filePath || "(\u5A92\u4F53\u53D1\u9001\u5931\u8D25)";
+        text = `${text}
+
+\u{1F4CE} \u5A92\u4F53\u53D1\u9001\u5931\u8D25\uFF0C\u515C\u5E95\u94FE\u63A5/\u8DEF\u5F84\uFF1A${mediaHint}`.trim();
+        log?.warn?.("[DingTalk] Media upload failed, falling back to text description");
       }
     } else {
       const mediaHint = options.mediaUrl || options.mediaPath || options.filePath || "(\u5A92\u4F53\u53D1\u9001\u5931\u8D25)";
       text = `${text}
 
-\u{1F4CE} \u5A92\u4F53\u53D1\u9001\u5931\u8D25\uFF0C\u515C\u5E95\u94FE\u63A5/\u8DEF\u5F84\uFF1A${mediaHint}`.trim();
-      log?.warn?.("[DingTalk] Media upload failed, falling back to text description");
+\u{1F4CE} \u5F53\u524D\u4F1A\u8BDD\u65E0\u6CD5\u76F4\u63A5\u53D1\u9001 ${options.mediaType}\uFF0C\u515C\u5E95\u94FE\u63A5/\u8DEF\u5F84\uFF1A${mediaHint}`.trim();
+      log?.warn?.(
+        `[DingTalk] Session webhook does not support native ${options.mediaType} replies; falling back to text description`
+      );
     }
   }
   const textWithUploadedLocalImages = await replaceMarkdownLocalImages({
@@ -7733,6 +7787,48 @@ async function sendMessage(config, conversationId, text, options = {}) {
   try {
     const messageType = config.messageType || "markdown";
     const log = options.log || getLogger();
+    if (options.sessionWebhook && options.mediaPath && shouldRouteSessionMediaViaProactive(options.mediaType)) {
+      log?.debug?.(
+        `[DingTalk] Session webhook does not support ${options.mediaType} replies reliably; using proactive media API instead`
+      );
+      const proactiveMediaResult = await sendProactiveMedia(
+        config,
+        conversationId,
+        options.mediaPath,
+        options.mediaType,
+        options
+      );
+      if (!proactiveMediaResult.ok) {
+        log?.warn?.(
+          `[DingTalk] Proactive ${options.mediaType} reply failed; falling back to session markdown: ` + (proactiveMediaResult.error || "unknown")
+        );
+        const data = await sendBySession(config, options.sessionWebhook, text, options);
+        const delivery2 = extractOutboundDeliveryMetadata(data);
+        const messageId2 = delivery2.messageId || delivery2.processQueryKey || delivery2.outTrackId;
+        const persistedText = buildPersistedOutboundText(text, options);
+        persistOutboundMessageContext({
+          storePath: options.storePath,
+          accountId: options.accountId,
+          conversationId: options.conversationId || conversationId,
+          text: persistedText,
+          messageType: "outbound-media",
+          quotedRef: options.quotedRef,
+          log,
+          ...DEFAULT_OUTBOUND_SENDER,
+          chatType: inferConversationChatType(options.conversationId || conversationId),
+          delivery: {
+            ...delivery2,
+            kind: "session"
+          }
+        });
+        return { ok: true, data, messageId: messageId2 };
+      }
+      return {
+        ok: true,
+        data: proactiveMediaResult.data,
+        messageId: proactiveMediaResult.messageId
+      };
+    }
     if (messageType === "card" && options.card && !options.forceMarkdown) {
       const card = options.card;
       if (isCardInTerminalState(card.state)) {
@@ -7754,26 +7850,6 @@ async function sendMessage(config, conversationId, text, options = {}) {
         };
       }
     }
-    if (options.sessionWebhook && options.mediaPath && options.mediaType === "voice") {
-      log?.debug?.(
-        "[DingTalk] Session webhook does not support voice replies reliably; using proactive media API for this voice response"
-      );
-      const proactiveVoiceResult = await sendProactiveMedia(
-        config,
-        conversationId,
-        options.mediaPath,
-        options.mediaType,
-        options
-      );
-      if (!proactiveVoiceResult.ok) {
-        return { ok: false, error: proactiveVoiceResult.error || "Voice reply send failed" };
-      }
-      return {
-        ok: true,
-        data: proactiveVoiceResult.data,
-        messageId: proactiveVoiceResult.messageId
-      };
-    }
     if (options.sessionWebhook) {
       const data = await sendBySession(config, options.sessionWebhook, text, options);
       const delivery2 = extractOutboundDeliveryMetadata(data);
@@ -9061,8 +9137,6 @@ function createCardDraftController(params) {
     if (stopped || failed) {
       return;
     }
-    await contentLoop.flush();
-    await contentLoop.waitForInFlight();
     if (hasStreamingContent) {
       await clearStreamingContentFromCard();
     }
@@ -9265,6 +9339,7 @@ function createCardDraftController(params) {
         discardCurrentAnswer();
       } else {
         sealCurrentAnswer();
+        queueRender();
       }
       await beginBoundaryFlush();
       return;
@@ -9482,7 +9557,6 @@ function createCardReplyStrategy(ctx) {
   };
   const { mode, usedDeprecatedCardRealTimeStream } = resolveCardStreamingMode(config);
   const streamAnswerLive = mode === "answer" || mode === "all";
-  const renderAnswerBlocksLive = mode === "all";
   const streamThinkingLive = mode === "all";
   let lifecycleState = "open";
   const shouldAcceptAnswerSnapshot = () => lifecycleState === "open";
@@ -9510,6 +9584,7 @@ function createCardReplyStrategy(ctx) {
   let sawFinalDelivery = false;
   let latestReasoningSnapshot = "";
   let pendingNonImageMedia = [];
+  const processedMediaUrls = /* @__PURE__ */ new Set();
   const getRenderedTimeline = (options = {}) => {
     const fallbackAnswer = finalTextForFallback || (sawFinalDelivery ? EMPTY_FINAL_REPLY : void 0);
     return controller.getRenderedContent({
@@ -9616,7 +9691,10 @@ function createCardReplyStrategy(ctx) {
         finalTextForFallback = normalized.answerText;
         return;
       }
-      await controller.updateAnswer(normalized.answerText);
+      await controller.updateAnswer(normalized.answerText, {
+        stream: streamAnswerLive,
+        renderBlocks: !streamAnswerLive
+      });
     }
   };
   const rewriteLocalMarkdownImagesToPlaceholders = (text) => {
@@ -9652,7 +9730,8 @@ function createCardReplyStrategy(ctx) {
     }
     await controller.updateAnswer(answerSnapshot, {
       stream: streamAnswerLive,
-      renderBlocks: renderAnswerBlocksLive
+      // Active answer previews live in the content field; blockList is committed at boundaries/finalize.
+      renderBlocks: false
     });
   };
   const applySplitTextToTimeline = async (text, options = {}) => {
@@ -9674,6 +9753,11 @@ function createCardReplyStrategy(ctx) {
       if (candidate.classification !== "local") {
         continue;
       }
+      if (processedMediaUrls.has(candidate.url.trim())) {
+        const placeholder = buildImagePlaceholderText({ alt: candidate.alt, url: candidate.url });
+        nextText = `${nextText.slice(0, candidate.start)}${placeholder}${nextText.slice(candidate.end)}`;
+        continue;
+      }
       let prepared;
       try {
         prepared = await prepareMediaInput(candidate.url, log, config.mediaUrlAllowlist);
@@ -9686,6 +9770,7 @@ function createCardReplyStrategy(ctx) {
         if (!result?.mediaId) {
           continue;
         }
+        processedMediaUrls.add(candidate.url.trim());
         const placeholder = buildImagePlaceholderText({ alt: candidate.alt, url: candidate.url });
         const blockText = candidate.alt.trim() || placeholder.replace(/^见下图/, "").trim() || "\u56FE\u7247";
         successfulReroutes.push({
@@ -9712,6 +9797,11 @@ function createCardReplyStrategy(ctx) {
         // Card mode keeps runtime block streaming disabled, but still consumes
         // reasoning blocks through explicit callbacks and delivery metadata.
         disableBlockStreaming: ctx.disableBlockStreaming ?? true,
+        // DingTalk card mode owns the visible reply surface. In group chats,
+        // OpenClaw defaults source replies to message-tool-only; override that
+        // so final replies are delivered into this card instead of spawning a
+        // separate visible message/card via the message tool.
+        sourceReplyDeliveryMode: "automatic",
         onAssistantMessageStart: async () => {
           if (isLifecycleSealed() || isStopRequested?.()) {
             return;
@@ -9780,6 +9870,10 @@ function createCardReplyStrategy(ctx) {
         );
         if (payload.mediaUrls.length > 0) {
           for (const url of payload.mediaUrls) {
+            const normalizedUrl = url.trim();
+            if (processedMediaUrls.has(normalizedUrl)) {
+              continue;
+            }
             try {
               const prepared = await prepareMediaInput(url, log, config.mediaUrlAllowlist);
               const mediaType = resolveOutboundMediaType({ mediaPath: prepared.path, asVoice: false });
@@ -9794,6 +9888,7 @@ function createCardReplyStrategy(ctx) {
               const result = await uploadMedia2(config, prepared.path, "image", log);
               await prepared.cleanup?.();
               if (result?.mediaId) {
+                processedMediaUrls.add(normalizedUrl);
                 await controller.appendImageBlock(result.mediaId);
               }
             } catch (err) {
@@ -9852,6 +9947,10 @@ function createCardReplyStrategy(ctx) {
       }
       if (payload.mediaUrls.length > 0) {
         for (const url of payload.mediaUrls) {
+          const normalizedUrl = url.trim();
+          if (processedMediaUrls.has(normalizedUrl)) {
+            continue;
+          }
           try {
             const prepared = await prepareMediaInput(url, log, config.mediaUrlAllowlist);
             const mediaType = resolveOutboundMediaType({ mediaPath: prepared.path, asVoice: false });
@@ -9864,6 +9963,7 @@ function createCardReplyStrategy(ctx) {
             const result = await uploadMedia2(config, prepared.path, "image", log);
             await prepared.cleanup?.();
             if (result?.mediaId) {
+              processedMediaUrls.add(normalizedUrl);
               await controller.appendImageBlock(result.mediaId);
             }
           } catch (err) {
@@ -9951,6 +10051,7 @@ function createCardReplyStrategy(ctx) {
       }
       try {
         await flushPendingReasoning();
+        await controller.clearStreamingContent?.();
         await controller.flush();
         await controller.waitForInFlight();
         const fallbackAnswer = finalTextForFallback || (sawFinalDelivery ? EMPTY_FINAL_REPLY : void 0);
@@ -10066,6 +10167,7 @@ function createCardReplyStrategy(ctx) {
 }
 
 // src/reply-strategy-markdown.ts
+import path8 from "node:path";
 var EMPTY_FINAL_FALLBACK_TEXT = "\u2705 Done";
 function renderQuotedSegment(text) {
   return text.split("\n").map((line) => line.length > 0 ? `> ${line}` : ">").join("\n");
@@ -10102,6 +10204,10 @@ function computeSharedPrefixTail(previous, next) {
   const suffix = current.slice(sharedPrefixLength);
   return suffix.trim() ? suffix : "";
 }
+function renderMarkdownImage(mediaPath) {
+  const filename = path8.basename(mediaPath) || "image";
+  return `![${filename}](${mediaPath})`;
+}
 function createMarkdownReplyStrategy(ctx) {
   let finalText;
   let activeAnswerText = "";
@@ -10125,7 +10231,7 @@ function createMarkdownReplyStrategy(ctx) {
     }
     sentVisibleContent = true;
   };
-  const emitAnswerSuffix = async (text) => {
+  const prepareAnswerSuffix = (text) => {
     const current = typeof text === "string" ? text : "";
     if (current.length > 0) {
       activeAnswerText = current;
@@ -10133,37 +10239,118 @@ function createMarkdownReplyStrategy(ctx) {
     }
     const suffix = computeIncrementalSuffix(lastSentAnswerText, current);
     if (suffix) {
-      await sendMarkdownSegment(suffix);
-      lastSentAnswerText = current;
-      return;
+      return {
+        text: suffix,
+        markSent: () => {
+          lastSentAnswerText = current;
+        }
+      };
     }
     if (current.trim() && lastSentAnswerText && !current.startsWith(lastSentAnswerText)) {
       const suffix2 = computeSharedPrefixTail(lastSentAnswerText, current);
       ctx.log?.warn?.(
         `[DingTalk][Markdown] answer prefix drift detected; falling back to shared-prefix tail prevLen=${lastSentAnswerText.length} currentLen=${current.length}`
       );
-      lastSentAnswerText = "";
       if (suffix2) {
-        await sendMarkdownSegment(suffix2);
-        lastSentAnswerText = current;
-        return;
+        return {
+          text: suffix2,
+          markSent: () => {
+            lastSentAnswerText = current;
+          }
+        };
+      }
+      return {
+        text: current,
+        markSent: () => {
+          lastSentAnswerText = current;
+        }
+      };
+    }
+    return null;
+  };
+  const emitAnswerSuffix = async (text) => {
+    const suffix = prepareAnswerSuffix(text);
+    if (suffix) {
+      await sendMarkdownSegment(suffix.text);
+      suffix.markSent();
+    }
+  };
+  const prepareMarkdownImageAttachments = async (mediaUrls) => {
+    const imageMarkdown = [];
+    const passthroughMediaUrls = [];
+    const cleanups = [];
+    for (const rawMediaUrl of mediaUrls) {
+      const preparedMedia = await prepareMediaInput(
+        rawMediaUrl,
+        ctx.log,
+        ctx.config.mediaUrlAllowlist
+      );
+      const actualMediaPath = preparedMedia.cleanup ? preparedMedia.path : resolveRelativePath(preparedMedia.path);
+      const mediaType = resolveOutboundMediaType({
+        mediaPath: actualMediaPath,
+        asVoice: false
+      });
+      if (mediaType === "image") {
+        imageMarkdown.push(renderMarkdownImage(actualMediaPath));
+        if (preparedMedia.cleanup) {
+          cleanups.push(preparedMedia.cleanup);
+        }
+      } else {
+        await preparedMedia.cleanup?.();
+        passthroughMediaUrls.push(rawMediaUrl);
       }
-      await sendMarkdownSegment(current);
-      lastSentAnswerText = current;
     }
+    return { imageMarkdown, passthroughMediaUrls, cleanups };
   };
   return {
     getReplyOptions() {
       return {
-        disableBlockStreaming: ctx.disableBlockStreaming === true
+        disableBlockStreaming: ctx.disableBlockStreaming === true,
+        // DingTalk markdown/sessionWebhook mode owns the visible reply surface.
+        // Keep runtime final replies on this strategy even when group chats
+        // default source replies to message-tool-only.
+        sourceReplyDeliveryMode: "automatic"
       };
     },
     async deliver(payload) {
+      let answerTextSentWithImages = false;
+      let toolTextSentWithImages = false;
       if (payload.mediaUrls.length > 0) {
-        await ctx.deliverMedia(payload.mediaUrls, { audioAsVoice: payload.audioAsVoice });
-        sentVisibleContent = true;
+        const prepared = payload.audioAsVoice === true ? {
+          imageMarkdown: [],
+          passthroughMediaUrls: payload.mediaUrls,
+          cleanups: []
+        } : await prepareMarkdownImageAttachments(payload.mediaUrls);
+        try {
+          if (prepared.passthroughMediaUrls.length > 0) {
+            await ctx.deliverMedia(prepared.passthroughMediaUrls, {
+              audioAsVoice: payload.audioAsVoice
+            });
+            sentVisibleContent = true;
+          }
+          if (prepared.imageMarkdown.length > 0) {
+            const answerSuffix = payload.kind === "block" || payload.kind === "final" ? prepareAnswerSuffix(payload.text) : typeof payload.text === "string" ? { text: renderQuotedSegment(payload.text), markSent: () => {
+            } } : null;
+            const markdownParts = [answerSuffix?.text || "", ...prepared.imageMarkdown].filter(
+              (part) => part.trim().length > 0
+            );
+            if (markdownParts.length > 0) {
+              await sendMarkdownSegment(markdownParts.join("\n\n"));
+              answerSuffix?.markSent();
+            }
+            answerTextSentWithImages = payload.kind === "block" || payload.kind === "final";
+            toolTextSentWithImages = payload.kind === "tool";
+          }
+        } finally {
+          for (const cleanup of prepared.cleanups) {
+            await cleanup();
+          }
+        }
       }
       if (payload.kind === "tool") {
+        if (toolTextSentWithImages) {
+          return;
+        }
         const text = typeof payload.text === "string" ? payload.text : "";
         if (!text.trim()) {
           return;
@@ -10171,7 +10358,7 @@ function createMarkdownReplyStrategy(ctx) {
         await sendMarkdownSegment(renderQuotedSegment(text));
         return;
       }
-      if ((payload.kind === "block" || payload.kind === "final") && typeof payload.text === "string") {
+      if ((payload.kind === "block" || payload.kind === "final") && typeof payload.text === "string" && !answerTextSentWithImages) {
         await emitAnswerSuffix(payload.text);
       }
     },
@@ -10386,46 +10573,61 @@ function buildAgentSessionKey(params) {
     identityLinks: cfg.session?.identityLinks
   }).toLowerCase();
 }
-function sanitizeAgentName(name) {
-  return name.replace(/[[\]\r\n]/g, "").trim();
-}
-async function resolveSubAgentRoute(params) {
-  const { extractedContent, cfg, isGroup, dingtalkConfig, sessionWebhook, senderId, log } = params;
+function resolveMessageTarget(params) {
+  const { extractedContent, cfg, isGroup } = params;
   const atMentions = extractedContent.atMentions || [];
-  const atUserDingtalkIds = isGroup ? extractedContent.atUserDingtalkIds : void 0;
+  if (atMentions.length === 0 || !cfg.agents?.list || cfg.agents.list.length === 0) {
+    return { kind: "default" };
+  }
   const textForCommandCheck = extractedContent.text.replace(/^\[引用[^\]]*\]\s*/, "");
-  const isLearnCommand = parseLearnCommand(textForCommandCheck).scope !== "unknown";
-  const textWithoutMentions = textForCommandCheck.replace(/^(?:@\S+\s+)*/u, "").trim();
-  const isSlashCommand = maybeResolveTextAlias(textWithoutMentions, cfg) !== null;
-  if (atMentions.length === 0 || !cfg.agents?.list || cfg.agents.list.length === 0 || isLearnCommand || isSlashCommand) {
-    return null;
+  if (parseLearnCommand(textForCommandCheck).scope !== "unknown") {
+    return { kind: "default" };
   }
-  const { matchedAgents, unmatchedNames, realUserCount, hasInvalidAgentNames } = resolveAtAgents(
+  const atUserDingtalkIds = isGroup ? extractedContent.atUserDingtalkIds : void 0;
+  const { matchedAgents, unmatchedNames, hasInvalidAgentNames } = resolveAtAgents(
     atMentions,
     cfg,
     atUserDingtalkIds
   );
-  log?.info?.(
-    `[DingTalk] Sub-agent resolve: matched=${matchedAgents.map((a) => a.agentId).join(",")} unmatched=${unmatchedNames.join(",")} realUsers=${realUserCount}`
-  );
-  if (hasInvalidAgentNames) {
-    const fallbackReason = `\u672A\u627E\u5230\u540D\u4E3A"${unmatchedNames.join("\u3001")}"\u7684\u52A9\u624B`;
-    try {
-      const sendOptions = isGroup ? { atUserId: senderId, log } : { log };
-      await sendBySession(dingtalkConfig, sessionWebhook, `\u26A0\uFE0F ${fallbackReason}`, {
-        ...sendOptions
-      });
-    } catch (err) {
-      log?.debug?.(`[DingTalk] Failed to send fallback notice: ${getErrorMessage(err)}`);
+  const commandText = textForCommandCheck.replace(/^(?:@\S+\s+)*/u, "").trim();
+  if (maybeResolveTextAlias(commandText, cfg) !== null) {
+    const firstMatch = matchedAgents[0];
+    if (firstMatch) {
+      return { kind: "subagent-command", agent: firstMatch, commandText };
     }
   }
-  if (matchedAgents.length === 0) {
-    return null;
+  if (matchedAgents.length === 0 && !hasInvalidAgentNames) {
+    return { kind: "default" };
+  }
+  return { kind: "subagent-content", matchedAgents, unmatchedNames, hasInvalidAgentNames };
+}
+function sanitizeAgentName(name) {
+  return name.replace(/[[\]\r\n]/g, "").trim();
+}
+async function sendUnmatchedAgentNotice(params) {
+  const { unmatchedNames, isGroup, senderId, dingtalkConfig, sessionWebhook, log } = params;
+  const fallbackReason = `\u672A\u627E\u5230\u540D\u4E3A"${unmatchedNames.join("\u3001")}"\u7684\u52A9\u624B`;
+  try {
+    const sendOptions = isGroup ? { atUserId: senderId, log } : { log };
+    await sendBySession(dingtalkConfig, sessionWebhook, `\u26A0\uFE0F ${fallbackReason}`, sendOptions);
+  } catch (err) {
+    log?.debug?.(`[DingTalk] Failed to send fallback notice: ${getErrorMessage(err)}`);
   }
-  return { matchedAgents };
 }
 async function dispatchSubAgents(params) {
-  const { matchedAgents, cfg, accountId, data, dingtalkConfig, sessionWebhook, extractedContent, handleMessage, downloadMedia: download, log } = params;
+  const {
+    matchedAgents,
+    commandText,
+    cfg,
+    accountId,
+    data,
+    dingtalkConfig,
+    sessionWebhook,
+    extractedContent,
+    handleMessage,
+    downloadMedia: download,
+    log
+  } = params;
   let preDownloadedMedia;
   const robotCode = resolveRobotCode(dingtalkConfig);
   if (robotCode) {
@@ -10460,18 +10662,17 @@ async function dispatchSubAgents(params) {
         dingtalkConfig,
         subAgentOptions: {
           agentId: agentMatch.agentId,
-          responsePrefix: `> \u{1F916} **${sanitizeAgentName(agentMatch.matchedName)}**:
+          responsePrefix: commandText ? "" : `> \u{1F916} **${sanitizeAgentName(agentMatch.matchedName)}**:
 
 `,
-          matchedName: agentMatch.matchedName
+          matchedName: agentMatch.matchedName,
+          commandText
         },
         preDownloadedMedia
       });
     } catch (error) {
       const message = getErrorMessage(error);
-      log?.error?.(
-        `[DingTalk] Sub-agent ${agentMatch.agentId} failed: ${message}`
-      );
+      log?.error?.(`[DingTalk] Sub-agent ${agentMatch.agentId} failed: ${message}`);
       if (error instanceof HostRoutingHelperUnavailableError && !helperMissingWarningSent) {
         helperMissingWarningSent = true;
         try {
@@ -10495,12 +10696,12 @@ async function dispatchSubAgents(params) {
 
 // src/targeting/group-members-store.ts
 import * as fs5 from "node:fs";
-import * as path8 from "node:path";
+import * as path9 from "node:path";
 var GROUP_MEMBERS_NAMESPACE = "members.group-roster";
 function groupMembersFilePath(storePath, groupId) {
-  const dir = path8.join(path8.dirname(storePath), "dingtalk-members");
+  const dir = path9.join(path9.dirname(storePath), "dingtalk-members");
   const safeId = groupId.replace(/\+/g, "-").replace(/\//g, "_");
-  return path8.join(dir, `${safeId}.json`);
+  return path9.join(dir, `${safeId}.json`);
 }
 function readLegacyRoster(storePath, groupId) {
   const filePath = groupMembersFilePath(storePath, groupId);
@@ -11191,7 +11392,7 @@ async function handleDingTalkMessage(params) {
     return;
   }
   const rawInboundText = extractedContent.text.trim();
-  if (subAgentOptions) {
+  if (subAgentOptions && !subAgentOptions.commandText) {
     const cleanText = extractedContent.text.replace(/^\[引用[^\]]*\]\s*/, "");
     const contextHint = `[\u4F60\u88AB @ \u4E3A"${subAgentOptions.matchedName}"]
 
@@ -11369,36 +11570,62 @@ async function handleDingTalkMessage(params) {
     peerIdOverride,
     config: dingtalkConfig
   });
-  const route = subAgentOptions ? {
-    agentId: subAgentOptions.agentId,
-    sessionKey: buildAgentSessionKey({
-      rt,
-      cfg,
-      accountId,
+  const messageTarget = subAgentOptions ? null : resolveMessageTarget({ extractedContent, cfg, isGroup });
+  let route;
+  if (subAgentOptions) {
+    route = {
       agentId: subAgentOptions.agentId,
-      peerKind: sessionPeer.kind,
-      peerId: sessionPeer.peerId
-    }),
-    mainSessionKey: ""
-  } : rt.channel.routing.resolveAgentRoute({
-    cfg,
-    channel: "dingtalk",
-    accountId,
-    peer: { kind: sessionPeer.kind, id: sessionPeer.peerId }
-  });
-  if (!subAgentOptions) {
-    const subAgentRoute = await resolveSubAgentRoute({
-      extractedContent,
+      sessionKey: buildAgentSessionKey({
+        rt,
+        cfg,
+        accountId,
+        agentId: subAgentOptions.agentId,
+        peerKind: sessionPeer.kind,
+        peerId: sessionPeer.peerId
+      }),
+      mainSessionKey: ""
+    };
+  } else {
+    route = rt.channel.routing.resolveAgentRoute({
       cfg,
-      isGroup,
-      dingtalkConfig,
-      sessionWebhook,
-      senderId,
-      log
+      channel: "dingtalk",
+      accountId,
+      peer: { kind: sessionPeer.kind, id: sessionPeer.peerId }
     });
-    if (subAgentRoute) {
+  }
+  if (messageTarget && messageTarget.kind !== "default") {
+    if (messageTarget.kind === "subagent-command") {
+      await dispatchSubAgents({
+        matchedAgents: [messageTarget.agent],
+        commandText: messageTarget.commandText,
+        cfg,
+        accountId,
+        data,
+        dingtalkConfig,
+        sessionWebhook,
+        extractedContent,
+        handleMessage: handleDingTalkMessage,
+        downloadMedia,
+        log
+      });
+      return;
+    }
+    if (messageTarget.hasInvalidAgentNames) {
+      await sendUnmatchedAgentNotice({
+        unmatchedNames: messageTarget.unmatchedNames,
+        isGroup,
+        senderId,
+        dingtalkConfig,
+        sessionWebhook,
+        log
+      });
+    }
+    if (messageTarget.matchedAgents.length > 0) {
+      log?.info?.(
+        `[DingTalk] Sub-agent resolve: matched=${messageTarget.matchedAgents.map((a) => a.agentId).join(",")} unmatched=${messageTarget.unmatchedNames.join(",")}`
+      );
       await dispatchSubAgents({
-        ...subAgentRoute,
+        matchedAgents: messageTarget.matchedAgents,
         cfg,
         accountId,
         data,
@@ -11422,7 +11649,7 @@ async function handleDingTalkMessage(params) {
     dingtalkConfig,
     senderId,
     isDirect,
-    extractedText: extractedContent.text,
+    extractedText: subAgentOptions?.commandText ?? extractedContent.text,
     messageType: extractedContent.messageType,
     data: {
       conversationId: data.conversationId,
@@ -11581,7 +11808,7 @@ async function handleDingTalkMessage(params) {
       if (!hasPathLikeShape) {
         return void 0;
       }
-      return STANDALONE_MEDIA_PATH_EXTENSIONS.has(path9.extname(trimmed).toLowerCase()) ? trimmed : void 0;
+      return STANDALONE_MEDIA_PATH_EXTENSIONS.has(path10.extname(trimmed).toLowerCase()) ? trimmed : void 0;
     }, extractSharedAudioAsVoice = function(payload, inlineReplyPayload) {
       const richPayload = payload;
       const sharedValue = parseBooleanLike(richPayload.audioAsVoice);
@@ -12045,6 +12272,7 @@ ${extracted.text}`;
     const inboundText = attachmentExtractedText ? `${inboundBody.trimEnd()}
 
 ${attachmentExtractedText}` : inboundBody;
+    const commandBody = subAgentOptions?.commandText ?? inboundText;
     const learningEnabled = isLearningEnabled(dingtalkConfig);
     const learningContextBlock = buildLearningContextBlock({
       enabled: learningEnabled,
@@ -12086,7 +12314,7 @@ ${attachmentExtractedText}` : inboundBody;
     const ctx = rt.channel.reply.finalizeInboundContext({
       Body: body,
       RawBody: inboundText,
-      CommandBody: inboundText,
+      CommandBody: commandBody,
       QuotedRef: quotedRef,
       QuotedRefJson: quotedRef ? JSON.stringify(quotedRef) : void 0,
       ReplyToId: quotedRuntimeContext?.replyToId,
@@ -13025,14 +13253,14 @@ var RegistrationError = class extends Error {
 function asString(value) {
   return typeof value === "string" ? value : "";
 }
-async function apiPost(path10, payload) {
-  const url = `${REGISTRATION_BASE_URL}${path10}`;
+async function apiPost(path11, payload) {
+  const url = `${REGISTRATION_BASE_URL}${path11}`;
   const resp = await http_client_default.post(url, payload, { timeout: 15e3 });
   const data = resp.data;
   const errcode = data.errcode;
   if (errcode !== void 0 && errcode !== 0) {
     const errmsg = asString(data.errmsg) || "unknown error";
-    throw new RegistrationError(`API error [${path10}]: ${errmsg} (errcode=${typeof errcode === "number" ? errcode : asString(errcode)})`);
+    throw new RegistrationError(`API error [${path11}]: ${errmsg} (errcode=${typeof errcode === "number" ? errcode : asString(errcode)})`);
   }
   return data;
 }