@soimy/dingtalk 3.6.2-beta.1 → 3.6.3

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";
@@ -261,7 +260,10 @@ export function createCardReplyStrategy(
         finalTextForFallback = normalized.answerText;
         return;
       }
-      await controller.updateAnswer(normalized.answerText);
+      await controller.updateAnswer(normalized.answerText, {
+        stream: streamAnswerLive,
+        renderBlocks: !streamAnswerLive,
+      });
     }
   };
 
@@ -304,7 +306,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,
     });
   };
 
@@ -388,6 +391,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?.()) {
@@ -671,6 +679,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);