@soimy/dingtalk 3.5.2 → 3.6.0

package/src/inbound-handler.ts

@@ -1,15 +1,19 @@
 import fs from "node:fs";
+import * as path from "node:path";
+import { isAbortRequestText, isBtwRequestText } from "openclaw/plugin-sdk/reply-runtime";
 import axios from "./http-client";
 import { normalizeAllowFrom, isSenderAllowed, resolveGroupAccess } from "./access-control";
 import { buildAgentSessionKey, resolveSubAgentRoute, dispatchSubAgents } from "./targeting/agent-routing";
+import { getAgentDisplayName } from "./targeting/agent-name-matcher";
 import { classifyAckReactionEmoji } from "./ack-reaction-classifier";
 import { attachNativeAckReaction } from "./ack-reaction-service";
 import { createDynamicAckReactionController } from "./ack-reaction/dynamic-ack-reaction-controller";
 import { extractAttachmentText } from "./messaging/attachment-text-extractor";
 import { getAccessToken } from "./auth";
-import { createAICard, finishAICard, isCardInTerminalState } from "./card-service";
+import { createAICard, commitAICardBlocks, isCardInTerminalState } from "./card-service";
+import { renderStatusLine } from "./card/statusline-renderer";
 import { handleInboundCommandDispatch } from "./command/inbound-command-dispatch-service";
-import { resolveAckReactionSetting, resolveGroupConfig, resolveRobotCode } from "./config";
+import { resolveAckReactionSetting, resolveGroupConfig, resolveRelativePath, resolveRobotCode } from "./config";
 import { AICardStatus } from "./types";
 import {
   isCardRunStopRequested,
@@ -29,6 +33,7 @@ import {
   upsertInboundMessageContext,
 } from "./message-context-store";
 import { extractMessageContent } from "./message-utils";
+import { deliverBtwReply, stripLeadingMentions } from "./messaging/btw-deliver";
 import { resolveQuotedRuntimeContext } from "./messaging/quoted-context";
 import {
   buildInboundQuotedRef,
@@ -42,7 +47,7 @@ import {
 } from "./proactive-risk-registry";
 import { downloadGroupFile, getUnionIdByStaffId, resolveQuotedFile } from "./messaging/quoted-file-service";
 import { createReplyStrategy } from "./reply-strategy";
-import type { DeliverPayload } from "./reply-strategy";
+import type { DeliverPayload } from "./reply-strategy-types";
 import { getDingTalkRuntime } from "./runtime";
 import { sendBySession, sendMessage, sendProactiveMedia } from "./send-service";
 import { acquireSessionLock } from "./session-lock";
@@ -52,18 +57,43 @@ import {
   setSessionPeerOverride,
 } from "./session-peer-store";
 import { resolveDingTalkSessionPeer } from "./session-routing";
+import { getSessionState, initSessionState } from "./session-state";
 import {
   upsertObservedGroupTarget,
   upsertObservedUserTarget,
 } from "./targeting/target-directory-store";
 import type { DingTalkConfig, HandleDingTalkMessageParams, Logger, MediaFile } from "./types";
-import { formatDingTalkErrorPayloadLog, getErrorMessage, getErrorResponseData, maskSensitiveData } from "./utils";
-import { isAbortRequestText } from "openclaw/plugin-sdk/reply-runtime";
+import { formatDingTalkErrorPayloadLog, getErrorMessage, getErrorResponseData, maskSensitiveData, parseBooleanLike } from "./utils";
+import { parseInlineDirectives } from "openclaw/plugin-sdk/text-runtime";
 
 const DEFAULT_PROACTIVE_HINT_COOLDOWN_HOURS = 24;
 const MIN_THINKING_REACTION_VISIBLE_MS = 1200;
 const MAX_DYNAMIC_ACK_DISPOSE_WAIT_MS = 500;
 const ATTACHMENT_TEXT_PREFIX = "[附件内容摘录]";
+const MEDIA_DIRECTIVE_PREFIX = "MEDIA:";
+const STANDALONE_MEDIA_PATH_EXTENSIONS = new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".bmp",
+  ".ogg",
+  ".amr",
+  ".mp3",
+  ".wav",
+  ".mp4",
+  ".avi",
+  ".mov",
+  ".doc",
+  ".docx",
+  ".xls",
+  ".xlsx",
+  ".ppt",
+  ".pptx",
+  ".zip",
+  ".pdf",
+  ".rar",
+]);
 const proactiveHintLastSentAt = new Map<string, number>();
 const sessionReasoningLevelCache = new Map<string, {
   updatedAt?: number;
@@ -71,6 +101,71 @@ const sessionReasoningLevelCache = new Map<string, {
 }>();
 type ReplyMode = "card" | "markdown";
 
+function resolveQuotedContextAllowFrom(
+  config: DingTalkConfig,
+  groupId: string,
+): string[] | undefined {
+  const groupConfig = resolveGroupConfig(config, groupId);
+  return groupConfig?.groupAllowFrom ?? config.groupAllowFrom;
+}
+
+function resolveQuotedVisibilitySenderId(params: {
+  quotedSenderId?: string;
+  currentSenderId: string;
+  currentSenderOriginalId: string;
+}): string | undefined {
+  const quotedSenderId = (params.quotedSenderId || "").trim();
+  if (!quotedSenderId) {
+    return undefined;
+  }
+  if (quotedSenderId === params.currentSenderOriginalId) {
+    return params.currentSenderId;
+  }
+  return quotedSenderId;
+}
+
+function filterQuotedRuntimeContext(params: {
+  context: ReturnType<typeof resolveQuotedRuntimeContext>;
+  config: DingTalkConfig;
+  isDirect: boolean;
+  groupId: string;
+  quotedSenderId?: string;
+  currentSenderId: string;
+  currentSenderOriginalId: string;
+}): ReturnType<typeof resolveQuotedRuntimeContext> {
+  const { context, config, isDirect, groupId, quotedSenderId, currentSenderId, currentSenderOriginalId } = params;
+  if (!context || isDirect) {
+    return context;
+  }
+
+  const mode = config.contextVisibility || "all";
+  if (mode === "all") {
+    return context;
+  }
+
+  const allow = normalizeAllowFrom(resolveQuotedContextAllowFrom(config, groupId));
+  const senderId = resolveQuotedVisibilitySenderId({
+    quotedSenderId,
+    currentSenderId,
+    currentSenderOriginalId,
+  });
+  const senderAllowed =
+    allow.hasEntries && !!senderId
+      ? isSenderAllowed({ allow, senderId })
+      : false;
+
+  if (senderAllowed) {
+    return context;
+  }
+  if (mode === "allowlist_quote") {
+    return {
+      ...context,
+      untrustedContext: undefined,
+    };
+  }
+  return null;
+}
+
 function readSessionReasoningLevel(params: {
   storePath?: string;
   sessionKey: string;
@@ -132,6 +227,29 @@ function shouldDisableBlockStreamingForReplyMode(params: {
   return shouldDisable;
 }
 
+function resolveLegacyCardStreamReasoningForInternalUse(params: {
+  cfg: HandleDingTalkMessageParams["cfg"];
+  accountId: string;
+}): boolean | undefined {
+  const dingtalk = (params.cfg?.channels?.dingtalk ?? null) as
+    | (Record<string, unknown> & {
+        cardStreamReasoning?: unknown;
+        accounts?: Record<string, Record<string, unknown> | undefined>;
+      })
+    | null;
+  if (!dingtalk) {
+    return undefined;
+  }
+  const accountConfig = params.accountId ? dingtalk.accounts?.[params.accountId] : undefined;
+  if (typeof accountConfig?.cardStreamReasoning === "boolean") {
+    return accountConfig.cardStreamReasoning;
+  }
+  if (typeof dingtalk.cardStreamReasoning === "boolean") {
+    return dingtalk.cardStreamReasoning;
+  }
+  return undefined;
+}
+
 function resolvePinnedMainDmOwner(params: {
   dmScope?: string;
   allowFrom?: string[];
@@ -273,6 +391,8 @@ function buildGroupTurnContextPrompt(params: {
 type ReplyStreamPayload = {
   text?: string;
   isReasoning?: boolean;
+  mediaUrl?: string;
+  mediaUrls?: string[];
 };
 
 type ReplyChunkInfo = {
@@ -290,6 +410,7 @@ export async function downloadMedia(
   config: DingTalkConfig,
   downloadCode: string,
   log?: any,
+  originalFilename?: string,
 ): Promise<MediaFile | null> {
   const rt = getDingTalkRuntime();
   let downloadUrl: string | undefined;
@@ -363,9 +484,13 @@ export async function downloadMedia(
 
     const maxBytes =
       config.mediaMaxMb && config.mediaMaxMb > 0 ? config.mediaMaxMb * 1024 * 1024 : undefined;
-    const saved = maxBytes
-      ? await rt.channel.media.saveMediaBuffer(buffer, contentType, "inbound", maxBytes)
-      : await rt.channel.media.saveMediaBuffer(buffer, contentType, "inbound");
+    const saved = await rt.channel.media.saveMediaBuffer(
+      buffer,
+      contentType,
+      "inbound",
+      maxBytes,
+      originalFilename,
+    );
     log?.debug?.(`[DingTalk] Media saved: ${saved.path}`);
     return { path: saved.path, mimeType: saved.contentType ?? contentType };
   } catch (err: any) {
@@ -415,6 +540,10 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     return;
   }
 
+  // Preserve raw inbound text before any rewriting (e.g., sub-agent context hint)
+  // for use in card quoteContent which should show the user's original message.
+  const rawInboundText = extractedContent.text.trim();
+
   // Add context hint for sub-agent mode, stripping quoted prefix to avoid protocol noise in agent context.
   if (subAgentOptions) {
     const cleanText = extractedContent.text.replace(/^\[引用[^\]]*\]\s*/, "");
@@ -689,21 +818,51 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   if (commandHandled) {
     return;
   }
+
+  const journalTTLDays = dingtalkConfig.journalTTLDays ?? DEFAULT_MESSAGE_CONTEXT_TTL_DAYS;
+  const quotedRef = buildInboundQuotedRef(data, extractedContent);
+  const replyQuotedRef = createReplyQuotedRef(data.msgId);
+  const content = extractedContent;
+  const isBtwBypass = isBtwRequestText(stripLeadingMentions(content.text).trim());
+  const taskInfoConversationId = groupId || to;
+  const sessionTaskState = initSessionState(accountId, taskInfoConversationId);
+  const initialStatusLine = renderStatusLine({
+    model: sessionTaskState.model,
+    effort: sessionTaskState.effort,
+    agent: getAgentDisplayName({
+      subAgentOptions,
+      agentId: route.agentId,
+      agentsList: cfg.agents?.list,
+    }),
+  }, dingtalkConfig) || undefined;
+
   // 3) Select response mode (card vs markdown).
   // Card creation runs BEFORE media download so the user sees immediate visual
   // feedback while large files are still being downloaded.
+  // /btw is gated out here (`!isBtwBypass`) because it must never create a card —
+  // it has its own bypass dispatch later that returns before reaching the main
+  // run. Abort (/stop) is intentionally NOT gated: in card mode the existing
+  // abort branch finalizes the card with the abort confirmation text instead of
+  // sending a separate plain-text message.
   let useCardMode = dingtalkConfig.messageType === "card";
   let currentAICard: import("./types").AICardInstance | undefined;
 
-  if (useCardMode) {
+  if (useCardMode && !isBtwBypass) {
     try {
       log?.debug?.(
         `[DingTalk][AICard] conversationType=${data.conversationType}, conversationId=${to}`,
       );
+      // quoteContent always shows the inbound message text so the user can
+      // identify which of their messages this card is replying to.
+      // Use rawInboundText ( preserved before sub-agent rewriting) to avoid
+      // showing internal routing context like "[你被 @ 为...]" in the card UI.
+      const inboundQuoteText = rawInboundText.slice(0, 200);
       const aiCard = await createAICard(dingtalkConfig, to, log, {
         accountId,
         storePath: accountStorePath,
         contextConversationId: groupId,
+        quoteContent: inboundQuoteText,
+        statusLine: initialStatusLine,
       });
       if (aiCard) {
         currentAICard = aiCard;
@@ -729,11 +888,6 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       );
     }
   }
-
-  const journalTTLDays = dingtalkConfig.journalTTLDays ?? DEFAULT_MESSAGE_CONTEXT_TTL_DAYS;
-  const quotedRef = buildInboundQuotedRef(data, extractedContent);
-  const replyQuotedRef = createReplyQuotedRef(data.msgId);
-  const content = extractedContent;
   const hasLegacyQuoteContent =
     typeof data.content?.quoteContent === "string" && data.content.quoteContent.trim().length > 0;
 
@@ -771,6 +925,8 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       messageType: content.messageType,
       text: content.text,
       quotedRef,
+      senderId,
+      senderName,
       createdAt: data.createAt,
       ttlMs: ttlDaysToMs(journalTTLDays),
       ttlReferenceMs: data.createAt,
@@ -795,7 +951,12 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     mediaType = preDownloadedMedia.mediaType;
   } else if (content.mediaPath && robotCode) {
     // Download media only if not pre-downloaded
-    const media = await downloadMedia(dingtalkConfig, content.mediaPath, log);
+    const media = await downloadMedia(
+      dingtalkConfig,
+      content.mediaPath,
+      log,
+      attachmentContextFileName,
+    );
     if (media) {
       mediaPath = media.path;
       mediaType = media.mimeType;
@@ -816,6 +977,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
         spaceId: data.content?.spaceId,
         fileId: data.content?.fileId,
       },
+      attachmentFileName: attachmentContextFileName,
       ttlMs: DEFAULT_MEDIA_CONTEXT_TTL_MS,
       topic: null,
     });
@@ -840,6 +1002,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
         spaceId: content.docSpaceId,
         fileId: content.docFileId,
       },
+      attachmentFileName: attachmentContextFileName,
       ttlMs: DEFAULT_MEDIA_CONTEXT_TTL_MS,
       topic: null,
     });
@@ -853,6 +1016,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
           content.docFileId,
           unionId,
           log,
+          attachmentContextFileName,
         );
         if (docMedia) {
           mediaPath = docMedia.path;
@@ -871,22 +1035,30 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     quotedRef,
     log,
   });
-  const quotedRuntimeContext = resolveQuotedRuntimeContext({
-    storePath: accountStorePath,
-    accountId,
-    conversationId: data.conversationId,
-    quotedRef,
-    firstRecord: quotedRecord,
-    firstPreview:
-      content.quoted?.previewText ||
-      content.quoted?.previewMessageType
-        ? {
-            text: content.quoted.previewText,
-            messageType: content.quoted.previewMessageType,
-            senderId: content.quoted.previewSenderId,
-          }
-        : undefined,
-    log,
+  const quotedRuntimeContext = filterQuotedRuntimeContext({
+    context: resolveQuotedRuntimeContext({
+      storePath: accountStorePath,
+      accountId,
+      conversationId: data.conversationId,
+      quotedRef,
+      firstRecord: quotedRecord,
+      firstPreview:
+        content.quoted?.previewText ||
+        content.quoted?.previewMessageType
+          ? {
+              text: content.quoted.previewText,
+              messageType: content.quoted.previewMessageType,
+              senderId: content.quoted.previewSenderId,
+            }
+          : undefined,
+      log,
+    }),
+    config: dingtalkConfig,
+    isDirect,
+    groupId,
+    quotedSenderId: quotedRecord?.senderId || content.quoted?.previewSenderId,
+    currentSenderId: senderId,
+    currentSenderOriginalId: senderOriginalId,
   });
 
   // Try downloading a quoted file from cached downloadCode/spaceId+fileId.
@@ -899,13 +1071,14 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
         fileId?: string;
       };
     } | null,
+    originalFilename?: string,
   ): Promise<MediaFile | null> => {
     if (!record?.media) {
       return null;
     }
     let media: MediaFile | null = null;
     if (record.media.downloadCode) {
-      media = await downloadMedia(dingtalkConfig, record.media.downloadCode, log);
+      media = await downloadMedia(dingtalkConfig, record.media.downloadCode, log, originalFilename);
       if (media) {
         log?.debug?.(
           `[DingTalk][QuotedRef] Recovered quoted media from cached downloadCode ` +
@@ -922,6 +1095,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
           record.media.fileId,
           unionId,
           log,
+          originalFilename,
         );
         if (media) {
           log?.debug?.(
@@ -938,9 +1112,15 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
 
   // Quoted picture: download via existing downloadMedia.
   if (!mediaPath && content.quoted?.mediaDownloadCode && robotCode) {
+    const quotedOriginalFilename = content.quoted.previewFileName;
     const media =
-      (await tryDownloadFromRecord(quotedRecord)) ||
-      (await downloadMedia(dingtalkConfig, content.quoted.mediaDownloadCode, log));
+      (await tryDownloadFromRecord(quotedRecord, quotedOriginalFilename)) ||
+      (await downloadMedia(
+        dingtalkConfig,
+        content.quoted.mediaDownloadCode,
+        log,
+        quotedOriginalFilename,
+      ));
     if (media) {
       if (!quotedRecord) {
         log?.debug?.(
@@ -965,7 +1145,12 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
 
     // Step 0: Direct download via downloadCode from quoted payload (file/audio/video msgType).
     if (!fileResolved && content.quoted.fileDownloadCode && robotCode) {
-      const media = await downloadMedia(dingtalkConfig, content.quoted.fileDownloadCode, log);
+      const media = await downloadMedia(
+        dingtalkConfig,
+        content.quoted.fileDownloadCode,
+        log,
+        content.quoted.previewFileName,
+      );
       if (media) {
         mediaPath = media.path;
         mediaType = media.mimeType;
@@ -982,7 +1167,10 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
 
     // Step 1: Prefer quotedRef-backed record lookup, then msgId-based cache.
     if (!fileResolved) {
-      const cachedMedia = await tryDownloadFromRecord(quotedRecord);
+      const cachedMedia = await tryDownloadFromRecord(
+        quotedRecord,
+        quotedRecord?.attachmentFileName || content.quoted.previewFileName,
+      );
       if (cachedMedia) {
         mediaPath = cachedMedia.path;
         mediaType = cachedMedia.mimeType;
@@ -1056,7 +1244,10 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   if (!mediaPath && content.quoted?.isQuotedDocCard) {
     let docResolved = false;
 
-    const cachedDocMedia = await tryDownloadFromRecord(quotedRecord);
+    const cachedDocMedia = await tryDownloadFromRecord(
+      quotedRecord,
+      quotedRecord?.attachmentFileName || content.quoted?.previewFileName,
+    );
     if (cachedDocMedia) {
       mediaPath = cachedDocMedia.path;
       mediaType = cachedDocMedia.mimeType;
@@ -1280,7 +1471,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   // "@Agent /stop" are correctly recognised as abort requests in both DM and group
   // chats. In groups DingTalk usually strips @BotName at the protocol level, but
   // in DMs with multi-agent routing the @mention prefix survives all the way here.
-  const textForAbortCheck = inboundText.replace(/^(?:@\S+\s+)*/u, "").trim();
+  const textForAbortCheck = stripLeadingMentions(inboundText).trim();
   if (isAbortRequestText(textForAbortCheck)) {
     log?.info?.(
       `[DingTalk] Abort request detected, bypassing session lock for session=${route.sessionKey}`,
@@ -1332,9 +1523,19 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     }
     // Finalize the card that was created for this message before the abort check.
     // Without this, the card stays in PROCESSING ("处理中...") indefinitely.
+    // Use V2 finalize (commitAICardBlocks) for consistent state transition.
     if (currentAICard && !isCardInTerminalState(currentAICard.state)) {
       try {
-        await finishAICard(currentAICard, abortConfirmationText ?? "已停止", log);
+        const abortText = abortConfirmationText ?? "已停止";
+        const abortBlockList = [{ type: 0, markdown: abortText }];
+        const blockListJson = JSON.stringify(abortBlockList);
+
+        await commitAICardBlocks(currentAICard, {
+          blockListJson,
+          content: abortText,
+        }, log);
+
+        log?.debug?.(`[DingTalk] Abort card finalized via V2 API: card=${currentAICard.cardInstanceId}`);
       } catch (cardErr) {
         log?.warn?.(`[DingTalk] Abort card finalize failed: ${getErrorMessage(cardErr)}`);
         currentAICard.state = AICardStatus.FAILED;
@@ -1343,6 +1544,61 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     return;
   }
 
+  // ---- Pre-lock BTW: bypass session lock for /btw side questions ----
+  // /btw runs an isolated, tool-less side query in openclaw without polluting
+  // the main run's transcript. The dispatch must NOT acquire the session lock,
+  // otherwise it would queue behind the in-flight main task and lose its "side
+  // question" semantics.
+  //
+  // The `isBtwBypass` flag is computed once early (just after `content` is
+  // resolved, just before `createAICard`). The same constant gates `createAICard` above and
+  // drives this branch — single decision, two consequences. See the comment
+  // at the flag's definition for why /btw uses pre-OCR `content.text` while
+  // abort uses `inboundText`.
+  if (isBtwBypass) {
+    log?.info?.(
+      `[DingTalk] BTW request detected, bypassing session lock for session=${route.sessionKey}`,
+    );
+    // Empty fallback (NOT "Unknown" like the file's main `senderName` variable):
+    // when the nickname is missing we want the blockquote to render as
+    // `> /btw <question>` rather than `> Unknown: /btw <question>`. Read locally
+    // here so the existing `senderName` semantics elsewhere in the file are not
+    // affected.
+    const btwSenderName = data.senderNick || "";
+    try {
+      await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx,
+        cfg,
+        dispatcherOptions: {
+          responsePrefix: "",
+          deliver: async (payload) => {
+            if (!payload.text) {
+              log?.debug?.(`[DingTalk] BTW deliver received non-text payload, skipping`);
+              return;
+            }
+            await deliverBtwReply({
+              config: dingtalkConfig,
+              sessionWebhook,
+              conversationId: groupId,
+              to,
+              senderName: btwSenderName,
+              // Use pre-OCR content.text (consistent with isBtwBypass detection)
+              // so the blockquote shows the user's typed body, not body + OCR.
+              rawQuestion: content.text,
+              replyText: payload.text,
+              log,
+              accountId,
+              storePath: accountStorePath,
+            });
+          },
+        },
+      });
+    } catch (btwErr) {
+      log?.warn?.(`[DingTalk] BTW dispatch failed: ${getErrorMessage(btwErr)}`);
+    }
+    return;
+  }
+
   const ackReaction =
     typeof dingtalkConfig.ackReaction === "string"
       ? dingtalkConfig.ackReaction.trim()
@@ -1380,8 +1636,117 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     }
   }
 
+  function parseInlineReplyPayloadText(text: unknown): {
+    text?: string;
+    mediaUrls: string[];
+    audioAsVoice: boolean;
+  } {
+    if (typeof text !== "string") {
+      return { text: undefined, mediaUrls: [], audioAsVoice: false };
+    }
+
+    const normalizedText = text.replace(/\r\n/g, "\n");
+    const parsedInline = normalizedText.includes("[[")
+      ? parseInlineDirectives(normalizedText, {
+          stripAudioTag: true,
+          stripReplyTags: false,
+        })
+      : {
+          text: normalizedText,
+          audioAsVoice: false,
+          replyToCurrent: false,
+          hasAudioTag: false,
+          hasReplyTag: false,
+        };
+    const mediaUrls: string[] = [];
+    const contentLines: string[] = [];
+
+    for (const line of parsedInline.text.split("\n")) {
+      const trimmed = line.trim();
+      const mediaCandidate = trimmed.replace(/^(?:\[\[[^[\]]+\]\]\s*)+/, "");
+      if (mediaCandidate.startsWith(MEDIA_DIRECTIVE_PREFIX)) {
+        const mediaSource = mediaCandidate.slice(MEDIA_DIRECTIVE_PREFIX.length).trim();
+        if (mediaSource) {
+          mediaUrls.push(mediaSource);
+          continue;
+        }
+      }
+      contentLines.push(line);
+    }
+
+    const cleanedText = contentLines.join("\n").trim();
+    const inlineTextWasTransformed = parsedInline.text !== normalizedText;
+    if (mediaUrls.length === 0) {
+      const standaloneMediaSource = extractStandaloneMediaSource(cleanedText);
+      if (standaloneMediaSource) {
+        return {
+          text: undefined,
+          mediaUrls: [standaloneMediaSource],
+          audioAsVoice: parsedInline.audioAsVoice,
+        };
+      }
+    }
+
+    return {
+      // Keep ordinary text formatting stable except for newline normalization.
+      // Once inline parsing actually strips directives/media lines, return the
+      // cleaned body text instead of the original raw payload.
+      text: mediaUrls.length > 0 || inlineTextWasTransformed ? cleanedText || undefined : normalizedText,
+      mediaUrls,
+      audioAsVoice: parsedInline.audioAsVoice,
+    };
+  }
+
+  function extractStandaloneMediaSource(text: string): string | undefined {
+    const trimmed = text.trim();
+    if (!trimmed || trimmed.includes("\n") || /\s/.test(trimmed)) {
+      return undefined;
+    }
+
+    const hasPathLikeShape =
+      /^https?:\/\/\S+$/i.test(trimmed) ||
+      trimmed.startsWith("~/") ||
+      trimmed.startsWith("~\\") ||
+      trimmed.startsWith("./") ||
+      trimmed.startsWith(".\\") ||
+      trimmed.startsWith("../") ||
+      trimmed.startsWith("..\\") ||
+      trimmed.startsWith("/") ||
+      trimmed.startsWith("\\") ||
+      /^[a-zA-Z]:[\\/]/.test(trimmed) ||
+      trimmed.includes("/") ||
+      trimmed.includes("\\");
+    if (!hasPathLikeShape) {
+      return undefined;
+    }
+
+    return STANDALONE_MEDIA_PATH_EXTENSIONS.has(path.extname(trimmed).toLowerCase())
+      ? trimmed
+      : undefined;
+  }
+
   // ---- Shared media delivery helper ----
-  async function deliverMediaAttachments(urls: string[]) {
+  function extractSharedAudioAsVoice(
+    payload: ReplyStreamPayload,
+    inlineReplyPayload?: ReturnType<typeof parseInlineReplyPayloadText>,
+  ): boolean {
+    // Normalize all reply-time voice hints into the shared `audioAsVoice`
+    // semantic that strategies and media delivery use downstream.
+    const richPayload = payload as ReplyStreamPayload & {
+      audioAsVoice?: unknown;
+      asVoice?: unknown;
+    };
+    const sharedValue = parseBooleanLike(richPayload.audioAsVoice);
+    if (sharedValue !== undefined) {
+      return sharedValue;
+    }
+    if (parseBooleanLike(richPayload.asVoice) === true) {
+      return true;
+    }
+    return inlineReplyPayload?.audioAsVoice === true;
+  }
+
+  async function deliverMediaAttachments(urls: string[], options?: { audioAsVoice?: boolean }) {
     for (const rawMediaUrl of urls) {
       const preparedMedia = await prepareMediaInput(
         rawMediaUrl,
@@ -1389,10 +1754,12 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
         dingtalkConfig.mediaUrlAllowlist,
       );
       try {
-        const actualMediaPath = preparedMedia.path;
+        const actualMediaPath = preparedMedia.cleanup
+          ? preparedMedia.path
+          : resolveRelativePath(preparedMedia.path);
         const outMediaType = resolveOutboundMediaType({
           mediaPath: actualMediaPath,
-          asVoice: false,
+          asVoice: options?.audioAsVoice === true,
         });
         if (sessionWebhook) {
           const sendResult = await sendMessage(dingtalkConfig, to, "", {
@@ -1433,18 +1800,24 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   }
 
   // ---- Extract mediaUrls from runtime payload ----
-  function extractMediaUrls(payload: ReplyStreamPayload): string[] {
+  function extractMediaUrls(
+    payload: ReplyStreamPayload,
+    inlineReplyPayload?: ReturnType<typeof parseInlineReplyPayloadText>,
+  ): string[] {
     const richPayload = payload as typeof payload & {
       mediaUrl?: string;
       mediaUrls?: string[];
     };
-    return Array.isArray(richPayload.mediaUrls)
+    const explicitMediaUrls = Array.isArray(richPayload.mediaUrls)
       ? richPayload.mediaUrls.filter((entry: unknown) => typeof entry === "string" && entry.trim())
       : richPayload.mediaUrl &&
           typeof richPayload.mediaUrl === "string" &&
           richPayload.mediaUrl.trim()
         ? [richPayload.mediaUrl]
         : [];
+    return explicitMediaUrls.length > 0
+      ? explicitMediaUrls
+      : inlineReplyPayload?.mediaUrls ?? [];
   }
 
   // Serialize dispatchReply + card finalize per session to prevent the runtime
@@ -1503,8 +1876,30 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       sessionUpdatedAt: previousTimestamp,
       log,
     });
+    const legacyCardStreamReasoning = resolveLegacyCardStreamReasoningForInternalUse({
+      cfg,
+      accountId,
+    });
+    const strategyConfig =
+      legacyCardStreamReasoning === undefined
+        ? dingtalkConfig
+        : { ...dingtalkConfig, cardStreamReasoning: legacyCardStreamReasoning };
+    const sessionTaskState = getSessionState(accountId, taskInfoConversationId);
+    const taskMeta = {
+      model: sessionTaskState?.model,
+      effort: sessionTaskState?.effort,
+      elapsedMs: typeof sessionTaskState?.taskStartTime === "number"
+        ? Math.max(0, Date.now() - sessionTaskState.taskStartTime)
+        : undefined,
+      agent: getAgentDisplayName({
+        subAgentOptions,
+        agentId: route.agentId,
+        agentsList: cfg.agents?.list,
+      }),
+    };
+
     const strategy = createReplyStrategy({
-      config: dingtalkConfig,
+      config: strategyConfig,
       card: currentAICard,
       useCardMode: replyMode === "card",
       to,
@@ -1526,10 +1921,13 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       replyQuotedRef,
       deliverMedia: deliverMediaAttachments,
       isStopRequested: isCurrentCardStopRequested,
+      inboundText: rawInboundText,
+      taskMeta,
     });
 
     try {
-      await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+      let deliveredFinalCount = 0;
+      const dispatchResult = await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
         ctx,
         cfg,
         dispatcherOptions: {
@@ -1538,13 +1936,18 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
             if (isCurrentCardStopRequested()) {
               log?.debug?.("[DingTalk][CardStop] Ignoring reply delivery because stop was already requested");
               return;
-            }
+          }
             try {
-              const mediaUrls = extractMediaUrls(payload);
+              if (info?.kind === "final") {
+                deliveredFinalCount += 1;
+              }
+              const inlineReplyPayload = parseInlineReplyPayloadText(payload.text);
+              const mediaUrls = extractMediaUrls(payload, inlineReplyPayload);
               const richPayload = payload as ReplyStreamPayload & { isReasoning?: boolean };
               await strategy.deliver({
-                text: payload.text,
+                text: inlineReplyPayload.text,
                 mediaUrls,
+                audioAsVoice: extractSharedAudioAsVoice(payload, inlineReplyPayload),
                 kind: (info?.kind as DeliverPayload["kind"]) || "block",
                 isReasoning: richPayload.isReasoning === true,
               });
@@ -1560,6 +1963,43 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
         },
         replyOptions: strategy.getReplyOptions(),
       });
+
+      const bufferedFinal =
+        dispatchResult && typeof dispatchResult === "object" && "queuedFinal" in dispatchResult
+          ? (dispatchResult as { queuedFinal?: unknown }).queuedFinal
+          : undefined;
+      const finalCount =
+        dispatchResult && typeof dispatchResult === "object" && "counts" in dispatchResult
+          ? (dispatchResult as { counts?: { final?: unknown } }).counts?.final
+          : undefined;
+
+      log?.info?.(
+        `[DingTalk][Dispatch] completed — deliveredFinalCount=${deliveredFinalCount} ` +
+        `counts.final=${typeof finalCount === "number" ? finalCount : "n/a"} ` +
+        `queuedFinalType=${typeof bufferedFinal}`,
+      );
+
+      const bufferedFinalPayload =
+        typeof bufferedFinal === "string"
+          ? ({ text: bufferedFinal } satisfies ReplyStreamPayload)
+          : bufferedFinal && typeof bufferedFinal === "object"
+            ? (bufferedFinal as ReplyStreamPayload)
+            : undefined;
+
+      if (deliveredFinalCount === 0 && bufferedFinalPayload) {
+        const inlineReplyPayload = parseInlineReplyPayloadText(bufferedFinalPayload.text);
+        const mediaUrls = extractMediaUrls(bufferedFinalPayload, inlineReplyPayload);
+        const hasBufferedText = typeof bufferedFinalPayload.text === "string" && bufferedFinalPayload.text.trim().length > 0;
+        if (hasBufferedText || mediaUrls.length > 0) {
+          await strategy.deliver({
+            text: inlineReplyPayload.text,
+            mediaUrls,
+            audioAsVoice: extractSharedAudioAsVoice(bufferedFinalPayload, inlineReplyPayload),
+            kind: "final",
+            isReasoning: bufferedFinalPayload.isReasoning === true,
+          });
+        }
+      }
     } catch (dispatchErr: unknown) {
       const error = dispatchErr instanceof Error ? dispatchErr : new Error(getErrorMessage(dispatchErr));
       await strategy.abort(error);