@soimy/dingtalk 3.6.2 → 3.6.4

package/src/message-utils.ts

@@ -398,7 +398,10 @@ function isMarkdownTableSeparator(line: string): boolean {
     .replace(/\|$/, "")
     .split("|")
     .map((cell) => cell.trim());
-  return cells.length > 0 && cells.every((cell) => /^:?-{3,}:?$/.test(cell));
+  // DingTalk markdown requires :-: separator format (1 dash minimum).
+  // Note: single `-` cells in data rows would also match; this is an accepted trade-off
+  // for compatibility with DingTalk's recommended :-: separator format.
+  return cells.length > 0 && cells.every((cell) => /^:?-{1,}:?$/.test(cell));
 }
 
 function isMarkdownTableRow(line: string): boolean {
@@ -415,11 +418,96 @@ function parseMarkdownTableRow(line: string): string[] {
     .map((cell) => cell.trim());
 }
 
-function renderMarkdownTable(lines: string[]): string {
-  const rows = lines.map(parseMarkdownTableRow).filter((cells) => cells.length > 0);
-  return rows.map((cells) => cells.join(" | ")).join("  \n");
+/**
+ * Parse alignment from a separator cell.
+ * Returns 'left', 'center', 'right', or 'center' (default).
+ */
+function parseSeparatorAlignment(cell: string): "left" | "center" | "right" {
+  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";
+  }
+  // Default to center for bare dashes (standard markdown)
+  return "center";
+}
+
+/**
+ * Build separator row from alignment array.
+ */
+function buildSeparatorRow(alignments: ("left" | "center" | "right")[]): string {
+  const cells = alignments.map((align) => {
+    if (align === "left") {
+      return ":---";
+    }
+    if (align === "right") {
+      return "---:";
+    }
+    return ":---:";
+  });
+  return "|" + cells.join("|") + "|";
+}
+
+/**
+ * Render markdown table rows preserving original alignment.
+ * Extracts alignment from the separator row and applies it to output.
+ */
+function renderMarkdownTable(headerLine: string, separatorLine: string, dataLines: string[]): string {
+  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),
+  );
+
+  // Extract alignments from separator
+  const alignments: ("left" | "center" | "right")[] = [];
+  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("|") + "|";
+    });
+
+  // Insert separator after header row (works for header-only tables too)
+  rendered.splice(1, 0, separator);
+
+  return rendered.join("\n");
 }
 
+/**
+ * Convert markdown tables to DingTalk-compatible format.
+ * DingTalk's markdown renderer supports left/center/right alignment (:---, :---:, ---:).
+ * This function preserves the original alignment from the separator row.
+ * Tables inside code fences are preserved unchanged.
+ *
+ * Note: Despite the function name, this now produces DingTalk-compatible
+ * markdown tables rather than plain text. The name is preserved for API
+ * compatibility with the `convertMarkdownTables` config option.
+ */
 export function convertMarkdownTablesToPlainText(text: string): string {
   const lines = text.split("\n");
   const output: string[] = [];
@@ -441,13 +529,21 @@ export function convertMarkdownTablesToPlainText(text: string): string {
       isMarkdownTableRow(line) &&
       isMarkdownTableSeparator(lines[index + 1] || "")
     ) {
-      const tableLines = [line];
+      const headerLine = line;
+      const separatorLine = lines[index + 1] || "";
+      const dataLines: string[] = [];
       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);
+      // Ensure blank line before table for DingTalk markdown rendering
+      const lastOutput = output[output.length - 1];
+      if (lastOutput !== undefined && lastOutput.trim() !== "") {
+        output.push("");
+      }
+      output.push(renderedTable);
       continue;
     }
 

package/src/reply-strategy-card.ts

@@ -102,7 +102,6 @@ export function createCardReplyStrategy(
   };
   const { mode, usedDeprecatedCardRealTimeStream } = resolveCardStreamingMode(config);
   const streamAnswerLive = mode === "answer" || mode === "all";
-  const renderAnswerBlocksLive = mode === "all";
   const streamThinkingLive = mode === "all";
   let lifecycleState: CardReplyLifecycleState = "open";
   const shouldAcceptAnswerSnapshot = () => lifecycleState === "open";
@@ -134,6 +133,8 @@ export function createCardReplyStrategy(
   let latestReasoningSnapshot = "";
   /** Non-image media attachments deferred for out-of-card delivery. */
   let pendingNonImageMedia: DeferredMedia[] = [];
+  /** URLs already processed in this card session — prevents duplicate upload/send when the same mediaUrl appears in both a non-final and final deliver. */
+  const processedMediaUrls = new Set<string>();
 
   const getRenderedTimeline = (options: { preferFinalAnswer?: boolean } = {}): string => {
     const fallbackAnswer = finalTextForFallback || (sawFinalDelivery ? EMPTY_FINAL_REPLY : undefined);
@@ -261,7 +262,10 @@ export function createCardReplyStrategy(
         finalTextForFallback = normalized.answerText;
         return;
       }
-      await controller.updateAnswer(normalized.answerText);
+      await controller.updateAnswer(normalized.answerText, {
+        stream: streamAnswerLive,
+        renderBlocks: !streamAnswerLive,
+      });
     }
   };
 
@@ -304,7 +308,8 @@ export function createCardReplyStrategy(
 
     await controller.updateAnswer(answerSnapshot, {
       stream: streamAnswerLive,
-      renderBlocks: renderAnswerBlocksLive,
+      // Active answer previews live in the content field; blockList is committed at boundaries/finalize.
+      renderBlocks: false,
     });
   };
 
@@ -342,6 +347,12 @@ export function createCardReplyStrategy(
         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: Awaited<ReturnType<typeof prepareMediaInput>> | undefined;
       try {
         prepared = await prepareMediaInput(candidate.url, log, config.mediaUrlAllowlist);
@@ -358,6 +369,7 @@ export function createCardReplyStrategy(
           continue;
         }
 
+        processedMediaUrls.add(candidate.url.trim());
         const placeholder = buildImagePlaceholderText({ alt: candidate.alt, url: candidate.url });
         const blockText = candidate.alt.trim() || placeholder.replace(/^见下图/, "").trim() || "图片";
         successfulReroutes.push({
@@ -388,6 +400,11 @@ export function createCardReplyStrategy(
         // 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?.()) {
@@ -469,6 +486,10 @@ export function createCardReplyStrategy(
         // Inline media upload → image blocks in card; defer non-image attachments
         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 });
@@ -484,6 +505,7 @@ export function createCardReplyStrategy(
               const result = await uploadMedia(config, prepared.path, "image", log);
               await prepared.cleanup?.();
               if (result?.mediaId) {
+                processedMediaUrls.add(normalizedUrl);
                 await controller.appendImageBlock(result.mediaId);
               }
             } catch (err: unknown) {
@@ -547,6 +569,10 @@ export function createCardReplyStrategy(
       // ---- block: only handle reasoning/media (other text blocks are unused) ----
       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 });
@@ -559,6 +585,7 @@ export function createCardReplyStrategy(
             const result = await uploadMedia(config, prepared.path, "image", log);
             await prepared.cleanup?.();
             if (result?.mediaId) {
+              processedMediaUrls.add(normalizedUrl);
               await controller.appendImageBlock(result.mediaId);
             }
           } catch (err: unknown) {
@@ -671,6 +698,7 @@ export function createCardReplyStrategy(
       try {
         await flushPendingReasoning();
 
+        await controller.clearStreamingContent?.();
         await controller.flush();
         await controller.waitForInFlight();
 

package/src/reply-strategy-markdown.ts

@@ -6,7 +6,15 @@
  * Reasoning display is intentionally unsupported on DingTalk markdown.
  */
 
-import type { DeliverPayload, ReplyOptions, ReplyStrategy, ReplyStrategyContext } from "./reply-strategy-types";
+import path from "node:path";
+import { resolveRelativePath } from "./config";
+import { prepareMediaInput, resolveOutboundMediaType } from "./media-utils";
+import type {
+  DeliverPayload,
+  ReplyOptions,
+  ReplyStrategy,
+  ReplyStrategyContext,
+} from "./reply-strategy-types";
 import { sendMessage } from "./send-service";
 
 const EMPTY_FINAL_FALLBACK_TEXT = "✅ Done";
@@ -14,7 +22,7 @@ const EMPTY_FINAL_FALLBACK_TEXT = "✅ Done";
 function renderQuotedSegment(text: string): string {
   return text
     .split("\n")
-    .map((line) => line.length > 0 ? `> ${line}` : ">")
+    .map((line) => (line.length > 0 ? `> ${line}` : ">"))
     .join("\n");
 }
 
@@ -52,9 +60,12 @@ function computeSharedPrefixTail(previous: string, next: string): string {
   return suffix.trim() ? suffix : "";
 }
 
-export function createMarkdownReplyStrategy(
-  ctx: ReplyStrategyContext,
-): ReplyStrategy {
+function renderMarkdownImage(mediaPath: string): string {
+  const filename = path.basename(mediaPath) || "image";
+  return `![${filename}](${mediaPath})`;
+}
+
+export function createMarkdownReplyStrategy(ctx: ReplyStrategyContext): ReplyStrategy {
   let finalText: string | undefined;
   let activeAnswerText = "";
   let lastSentAnswerText = "";
@@ -79,7 +90,10 @@ export function createMarkdownReplyStrategy(
     sentVisibleContent = true;
   };
 
-  const emitAnswerSuffix = async (text: string | undefined): Promise<void> => {
+  const prepareAnswerSuffix = (text: string | undefined): {
+    text: string;
+    markSent: () => void;
+  } | null => {
     const current = typeof text === "string" ? text : "";
     if (current.length > 0) {
       activeAnswerText = current;
@@ -88,42 +102,146 @@ export function createMarkdownReplyStrategy(
 
     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 suffix = computeSharedPrefixTail(lastSentAnswerText, current);
       ctx.log?.warn?.(
         `[DingTalk][Markdown] answer prefix drift detected; falling back to shared-prefix tail ` +
-        `prevLen=${lastSentAnswerText.length} currentLen=${current.length}`,
+          `prevLen=${lastSentAnswerText.length} currentLen=${current.length}`,
       );
-      lastSentAnswerText = "";
       if (suffix) {
-        await sendMarkdownSegment(suffix);
-        lastSentAnswerText = current;
-        return;
+        return {
+          text: suffix,
+          markSent: () => {
+            lastSentAnswerText = current;
+          },
+        };
       }
-      await sendMarkdownSegment(current);
-      lastSentAnswerText = current;
+      return {
+        text: current,
+        markSent: () => {
+          lastSentAnswerText = current;
+        },
+      };
+    }
+
+    return null;
+  };
+
+  const emitAnswerSuffix = async (text: string | undefined): Promise<void> => {
+    const suffix = prepareAnswerSuffix(text);
+    if (suffix) {
+      await sendMarkdownSegment(suffix.text);
+      suffix.markSent();
     }
   };
 
+  const prepareMarkdownImageAttachments = async (
+    mediaUrls: string[],
+  ): Promise<{
+    imageMarkdown: string[];
+    passthroughMediaUrls: string[];
+    cleanups: Array<() => Promise<void>>;
+  }> => {
+    const imageMarkdown: string[] = [];
+    const passthroughMediaUrls: string[] = [];
+    const cleanups: Array<() => Promise<void>> = [];
+
+    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);
+      }
+    }
+
+    return { imageMarkdown, passthroughMediaUrls, cleanups };
+  };
+
   return {
     getReplyOptions(): ReplyOptions {
       return {
         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: DeliverPayload): Promise<void> {
+      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;
@@ -133,8 +251,9 @@ export function createMarkdownReplyStrategy(
       }
 
       if (
-        (payload.kind === "block" || payload.kind === "final")
-        && typeof payload.text === "string"
+        (payload.kind === "block" || payload.kind === "final") &&
+        typeof payload.text === "string" &&
+        !answerTextSentWithImages
       ) {
         await emitAnswerSuffix(payload.text);
       }

package/src/reply-strategy-types.ts

@@ -16,6 +16,8 @@ export type InternalReplyStrategyConfig = DingTalkConfig & {
   cardStreamReasoning?: boolean;
 };
 
+export type SourceReplyDeliveryMode = "automatic" | "message_tool_only";
+
 // ---- Public interfaces ----
 
 export interface DeliverPayload {
@@ -33,6 +35,7 @@ export interface DeliverPayload {
 
 export interface ReplyOptions {
   disableBlockStreaming: boolean;
+  sourceReplyDeliveryMode?: SourceReplyDeliveryMode;
   onPartialReply?: (payload: { text?: string }) => void | Promise<void>;
   onReasoningStream?: (payload: { text?: string }) => void | Promise<void>;
   onAssistantMessageStart?: () => void | Promise<void>;

package/src/send-service.ts

@@ -182,6 +182,10 @@ function buildPersistedOutboundText(text: string, options: SendMessageOptions):
   return text;
 }
 
+function shouldRouteSessionMediaViaProactive(mediaType?: string | null): mediaType is "voice" | "video" | "file" {
+  return mediaType === "voice" || mediaType === "video" || mediaType === "file";
+}
+
 const DINGTALK_TEXT_CHUNK_LIMIT = 3800;
 const CARD_MEDIA_CONTROLLER_ATTACH_WAIT_MS = 150;
 const CARD_MEDIA_CONTROLLER_ATTACH_POLL_MS = 25;
@@ -726,55 +730,30 @@ export async function sendBySession(
   const token = await getAccessToken(config, options.log);
   const log = options.log || getLogger();
 
-  // Session webhook supports native media messages; prefer that when media info is available.
+  // Keep session webhooks on text/markdown. Images can render through markdown
+  // media references; other media types are routed by sendMessage via OpenAPI.
   if (options.mediaPath && options.mediaType) {
-    const uploadResult = await uploadMedia(config, options.mediaPath, options.mediaType, log, {
-      mediaLocalRoots: options.mediaLocalRoots,
-    });
-    if (uploadResult) {
-      const { mediaId, buffer, durationMs: uploadedDurationMs } = uploadResult;
-      let body: any;
-
-      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 axios({
-          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 uploadMedia(config, options.mediaPath, options.mediaType, log, {
+        mediaLocalRoots: options.mediaLocalRoots,
+      });
+      if (uploadResult) {
+        const imageMarkdown = `![${path.basename(options.mediaPath)}](${uploadResult.mediaId})`;
+        text = text ? `${text}\n\n${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 || "(媒体发送失败)";
+        text = `${text}\n\n📎 媒体发送失败，兜底链接/路径：${mediaHint}`.trim();
+        log?.warn?.("[DingTalk] Media upload failed, falling back to text description");
       }
     } else {
       const mediaHint = options.mediaUrl || options.mediaPath || options.filePath || "(媒体发送失败)";
-      text = `${text}\n\n📎 媒体发送失败，兜底链接/路径：${mediaHint}`.trim();
-      log?.warn?.("[DingTalk] Media upload failed, falling back to text description");
+      text = `${text}\n\n📎 当前会话无法直接发送 ${options.mediaType}，兜底链接/路径：${mediaHint}`.trim();
+      log?.warn?.(
+        `[DingTalk] Session webhook does not support native ${options.mediaType} replies; falling back to text description`,
+      );
     }
   }
 
@@ -835,6 +814,51 @@ export async function sendMessage(
     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 delivery = extractOutboundDeliveryMetadata(data);
+        const messageId = delivery.messageId || delivery.processQueryKey || delivery.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: {
+            ...delivery,
+            kind: "session",
+          },
+        });
+        return { ok: true, data, messageId };
+      }
+      return {
+        ok: true,
+        data: proactiveMediaResult.data,
+        messageId: proactiveMediaResult.messageId,
+      };
+    }
+
     if (messageType === "card" && options.card && !options.forceMarkdown) {
       const card = options.card;
       if (isCardInTerminalState(card.state)) {
@@ -858,28 +882,6 @@ export async function sendMessage(
       }
     }
 
-    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 delivery = extractOutboundDeliveryMetadata(data);