@yaoyuanchao/dingtalk 1.2.1 → 1.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaoyuanchao/dingtalk",
-  "version": "1.2.1",
+  "version": "1.3.1",
   "type": "module",
   "description": "DingTalk channel plugin for Clawdbot with Stream Mode support",
   "license": "MIT",

package/src/api.ts

@@ -7,8 +7,8 @@ import os from "node:os";
 const DINGTALK_API_BASE = "https://api.dingtalk.com/v1.0";
 const DINGTALK_OAPI_BASE = "https://oapi.dingtalk.com";
 
-/** Temp directory for downloaded pictures */
-const TEMP_DIR = path.join(os.tmpdir(), "dingtalk-pictures");
+/** Temp directory for downloaded media files */
+const TEMP_DIR = path.join(os.tmpdir(), "dingtalk-media");
 
 /** Cache access tokens per clientId */
 const tokenCache = new Map<string, { token: string; expiresAt: number }>();
@@ -359,8 +359,78 @@ export async function downloadPicture(
   }
 }
 
-/** Clean up old picture files (older than 1 hour) */
-export function cleanupOldPictures(): void {
+/** Extension mapping for media types */
+const MEDIA_EXTENSIONS: Record<string, string> = {
+  'image/jpeg': '.jpg',
+  'image/png': '.png',
+  'image/gif': '.gif',
+  'image/webp': '.webp',
+  'audio/amr': '.amr',
+  'audio/mpeg': '.mp3',
+  'audio/mp4': '.m4a',
+  'video/mp4': '.mp4',
+  'application/pdf': '.pdf',
+  'application/octet-stream': '.bin',
+};
+
+/** Download media file (picture/audio/video/file) from DingTalk */
+export async function downloadMediaFile(
+  clientId: string,
+  clientSecret: string,
+  robotCode: string,
+  downloadCode: string,
+  mediaType?: string,
+): Promise<{ filePath?: string; mimeType?: string; error?: string }> {
+  try {
+    const token = await getDingTalkAccessToken(clientId, clientSecret);
+
+    const url = `${DINGTALK_API_BASE}/robot/messageFiles/download`;
+    const headers = { "x-acs-dingtalk-access-token": token };
+    const body = { downloadCode, robotCode };
+
+    const response = await jsonPost(url, body, headers);
+
+    if (response.errcode && response.errcode !== 0) {
+      console.warn(`[dingtalk] Media download failed: ${response.errmsg}`);
+      return { error: response.errmsg || "Download failed" };
+    }
+
+    if (response.downloadUrl) {
+      const mediaBuffer = await httpGetBuffer(response.downloadUrl);
+
+      if (!fs.existsSync(TEMP_DIR)) {
+        fs.mkdirSync(TEMP_DIR, { recursive: true });
+      }
+
+      // Determine file extension from content type or media type hint
+      const contentType = response.contentType || '';
+      const ext = MEDIA_EXTENSIONS[contentType]
+        || (mediaType === 'audio' ? '.amr' : undefined)
+        || (mediaType === 'video' ? '.mp4' : undefined)
+        || (mediaType === 'image' ? '.jpg' : undefined)
+        || '.bin';
+
+      const timestamp = Date.now();
+      const prefix = mediaType || 'media';
+      const filename = `${prefix}_${timestamp}${ext}`;
+      const filePath = path.join(TEMP_DIR, filename);
+
+      fs.writeFileSync(filePath, mediaBuffer);
+
+      console.log(`[dingtalk] Media downloaded: ${filePath} (${mediaBuffer.length} bytes, type=${contentType || mediaType || 'unknown'})`);
+
+      return { filePath, mimeType: contentType || undefined };
+    }
+
+    return { error: "No download URL in response" };
+  } catch (err) {
+    console.warn(`[dingtalk] Error downloading media:`, err);
+    return { error: String(err) };
+  }
+}
+
+/** Clean up old media files (older than 1 hour) */
+export function cleanupOldMedia(): void {
   try {
     if (!fs.existsSync(TEMP_DIR)) return;
 
@@ -373,10 +443,13 @@ export function cleanupOldPictures(): void {
 
       if (stats.mtimeMs < oneHourAgo) {
         fs.unlinkSync(filePath);
-        console.log(`[dingtalk] Cleaned up old picture: ${filePath}`);
+        console.log(`[dingtalk] Cleaned up old media: ${filePath}`);
       }
     }
   } catch (err) {
-    console.warn(`[dingtalk] Error cleaning up pictures:`, err);
+    console.warn(`[dingtalk] Error cleaning up media:`, err);
   }
 }
+
+/** @deprecated Use cleanupOldMedia() instead */
+export const cleanupOldPictures = cleanupOldMedia;

package/src/channel.ts

@@ -97,9 +97,15 @@ export const dingtalkPlugin = {
         messageFormat: {
           type: 'string',
           title: 'Message Format',
-          enum: ['text', 'markdown'],
+          enum: ['text', 'markdown', 'auto'],
           default: 'text',
-          description: 'text=plain text, markdown=DingTalk markdown (limited: no tables, use text for tables)',
+          description: 'text=plain text, markdown=always markdown, auto=detect markdown features in response',
+        },
+        showThinking: {
+          type: 'boolean',
+          title: 'Show Thinking Indicator',
+          default: false,
+          description: 'Send "正在思考..." feedback before AI processing begins',
         },
       },
       required: ['clientId', 'clientSecret'],
@@ -235,6 +241,16 @@ export const dingtalkPlugin = {
 
       log.info?.('[dingtalk] Starting Stream connection...');
 
+      // Record start activity
+      (runtime as any).channel?.activity?.record?.('dingtalk', account.accountId, 'start');
+
+      // Record stop activity on abort
+      if (signal) {
+        signal.addEventListener('abort', () => {
+          (runtime as any).channel?.activity?.record?.('dingtalk', account.accountId, 'stop');
+        }, { once: true });
+      }
+
       try {
         await startDingTalkMonitor({
           account,

package/src/config-schema.ts

@@ -9,8 +9,8 @@ export const groupPolicySchema = z.enum(['disabled', 'allowlist', 'open'], {
   description: 'Group chat access control policy',
 });
 
-export const messageFormatSchema = z.enum(['text', 'markdown', 'richtext'], {
-  description: 'Message format for bot responses (richtext is an alias for markdown)',
+export const messageFormatSchema = z.enum(['text', 'markdown', 'richtext', 'auto'], {
+  description: 'Message format for bot responses (richtext is an alias for markdown, auto detects markdown features)',
 });
 
 // DingTalk 配置 Schema
@@ -60,9 +60,14 @@ export const dingTalkConfigSchema = z.object({
       'Message format:\n' +
       '  - text: Plain text (recommended, supports tables)\n' +
       '  - markdown: DingTalk markdown (limited support, no tables)\n' +
-      '  - richtext: Alias for markdown (deprecated, use markdown instead)'
+      '  - richtext: Alias for markdown (deprecated, use markdown instead)\n' +
+      '  - auto: Auto-detect markdown features in response'
     ),
 
+  // 思考反馈
+  showThinking: z.boolean().default(false)
+    .describe('Send "正在思考..." feedback before AI responds'),
+
   // 高级配置（可选）
   textChunkLimit: z.number().int().positive().default(2000).optional()
     .describe('Text chunk size limit for long messages'),

package/src/monitor.ts

@@ -1,5 +1,5 @@
-import type { DingTalkRobotMessage, ResolvedDingTalkAccount } from "./types.js";
-import { sendViaSessionWebhook, sendMarkdownViaSessionWebhook, sendDingTalkRestMessage, batchGetUserInfo, downloadPicture, cleanupOldPictures } from "./api.js";
+import type { DingTalkRobotMessage, ResolvedDingTalkAccount, ExtractedMessage } from "./types.js";
+import { sendViaSessionWebhook, sendMarkdownViaSessionWebhook, sendDingTalkRestMessage, batchGetUserInfo, downloadPicture, downloadMediaFile, cleanupOldMedia } from "./api.js";
 import { getDingTalkRuntime } from "./runtime.js";
 
 export interface DingTalkMonitorContext {
@@ -18,11 +18,11 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
   }
 
   // Clean up old pictures on startup
-  cleanupOldPictures();
+  cleanupOldMedia();
 
   // Schedule periodic cleanup every hour
   const cleanupInterval = setInterval(() => {
-    cleanupOldPictures();
+    cleanupOldMedia();
   }, 60 * 60 * 1000); // 1 hour
 
   // Clean up on abort (only if abortSignal is provided)
@@ -80,32 +80,100 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
   setStatus?.({ running: true, lastStartAt: Date.now() });
 }
 
-async function processInboundMessage(
+/**
+ * Extract message content from DingTalk message into a structured format.
+ * Handles: text, richText, picture, audio, video, file.
+ */
+async function extractMessageContent(
   msg: DingTalkRobotMessage,
-  ctx: DingTalkMonitorContext,
-): Promise<void> {
-  const { account, cfg, log, setStatus } = ctx;
-  const runtime = getDingTalkRuntime();
+  account: ResolvedDingTalkAccount,
+  log?: any,
+): Promise<ExtractedMessage> {
+  const msgtype = msg.msgtype || 'text';
+  const content = msg.content;
+
+  switch (msgtype) {
+    case 'text': {
+      return {
+        text: msg.text?.content?.trim() ?? '',
+        messageType: 'text',
+      };
+    }
 
-  const isDm = msg.conversationType === "1";
-  const isGroup = msg.conversationType === "2";
+    case 'richText': {
+      const result = await extractRichTextContent(msg, account, log);
+      return { ...result, messageType: 'richText' };
+    }
 
-  // Debug: log full message structure for debugging
-  if (msg.msgtype === 'richText' || msg.picture || (msg.atUsers && msg.atUsers.length > 0)) {
-    log?.info?.("[dingtalk-debug] Full message structure:");
-    log?.info?.("[dingtalk-debug]   msgtype: " + msg.msgtype);
-    log?.info?.("[dingtalk-debug]   text: " + JSON.stringify(msg.text));
-    log?.info?.("[dingtalk-debug]   richText: " + JSON.stringify(msg.richText));
-    log?.info?.("[dingtalk-debug]   picture: " + JSON.stringify(msg.picture));
-    log?.info?.("[dingtalk-debug]   atUsers: " + JSON.stringify(msg.atUsers));
-    log?.info?.("[dingtalk-debug]   RAW MESSAGE: " + JSON.stringify(msg).substring(0, 500));
-  }
+    case 'picture': {
+      return extractPictureContent(msg, log);
+    }
+
+    case 'audio': {
+      // DingTalk provides speech recognition result in content.recognition
+      const recognition = content?.recognition;
+      const downloadCode = content?.downloadCode;
+      log?.info?.("[dingtalk] Audio message - recognition: " + (recognition || '(none)'));
+      return {
+        text: recognition || '[语音消息]',
+        mediaDownloadCode: downloadCode,
+        mediaType: 'audio',
+        messageType: 'audio',
+      };
+    }
+
+    case 'video': {
+      const downloadCode = content?.downloadCode;
+      log?.info?.("[dingtalk] Video message - downloadCode: " + (downloadCode || '(none)'));
+      return {
+        text: '[视频]',
+        mediaDownloadCode: downloadCode,
+        mediaType: 'video',
+        messageType: 'video',
+      };
+    }
+
+    case 'file': {
+      const downloadCode = content?.downloadCode;
+      const fileName = content?.fileName || '未知文件';
+      log?.info?.("[dingtalk] File message - fileName: " + fileName);
+      return {
+        text: `[文件: ${fileName}]`,
+        mediaDownloadCode: downloadCode,
+        mediaType: 'file',
+        mediaFileName: fileName,
+        messageType: 'file',
+      };
+    }
 
-  // Extract message content from text or richText
-  let rawBody = msg.text?.content?.trim() ?? "";
+    default: {
+      // Fallback: try text.content for unknown message types
+      const text = msg.text?.content?.trim() || '';
+      if (!text) {
+        log?.info?.("[dingtalk] Unknown msgtype: " + msgtype + ", no text content found");
+      }
+      return {
+        text: text || `[${msgtype}消息]`,
+        messageType: msgtype,
+      };
+    }
+  }
+}
 
-  // If text is empty, try to extract from richText
-  if (!rawBody && msg.richText) {
+/**
+ * Extract content from richText messages.
+ * Preserves all existing edge-case handling for DingTalk's varied richText formats.
+ */
+async function extractRichTextContent(
+  msg: DingTalkRobotMessage,
+  account: ResolvedDingTalkAccount,
+  log?: any,
+): Promise<{ text: string; mediaDownloadCode?: string; mediaType?: 'image' }> {
+  // First try: msg.text.content (DingTalk sometimes also provides text for richText)
+  let text = msg.text?.content?.trim() ?? '';
+
+  // Second try: msg.richText as various formats
+  if (!text && msg.richText) {
     try {
       const richTextStr = typeof msg.richText === 'string'
         ? msg.richText
@@ -114,71 +182,55 @@ async function processInboundMessage(
 
       const rt = msg.richText as any;
 
-      // Try multiple possible fields for text content
       if (typeof msg.richText === 'string') {
-        // If it's a string, use it directly
-        rawBody = msg.richText.trim();
+        text = msg.richText.trim();
       } else if (rt) {
-        // Try various possible field names
-        rawBody = rt.text?.trim()
+        text = rt.text?.trim()
           || rt.content?.trim()
           || rt.richText?.trim()
-          || "";
+          || '';
 
-        // If still empty, try to extract from richText array structure
-        if (!rawBody && Array.isArray(rt.richText)) {
+        if (!text && Array.isArray(rt.richText)) {
           const textParts: string[] = [];
           for (const item of rt.richText) {
-            // Handle different types of richText elements
             if (item.text) {
               textParts.push(item.text);
             } else if (item.content) {
               textParts.push(item.content);
             }
-            // Note: @mention text should be included in item.text by DingTalk
           }
-          rawBody = textParts.join('').trim();
+          text = textParts.join('').trim();
         }
       }
 
-      if (rawBody) {
-        log?.info?.("[dingtalk] Extracted from richText: " + rawBody.slice(0, 100));
+      if (text) {
+        log?.info?.("[dingtalk] Extracted from richText: " + text.slice(0, 100));
       }
     } catch (err) {
       log?.info?.("[dingtalk] Failed to parse richText: " + err);
     }
   }
 
-  // Additional fallback: try to get content from text.content even for richText messages
-  if (!rawBody && msg.text?.content) {
-    rawBody = msg.text.content.trim();
-    log?.info?.("[dingtalk] Using text.content as fallback: " + rawBody.slice(0, 100));
-  }
-
-  // Handle richText messages (when msgtype === 'richText', data is in msg.content.richText)
-  if (!rawBody && msg.msgtype === 'richText') {
-    const content = (msg as any).content;
-    log?.info?.("[dingtalk] RichText message - msg.content: " + JSON.stringify(content).substring(0, 200));
-
+  // Third try: msg.content.richText array (when msgtype === 'richText')
+  if (!text) {
+    const content = msg.content;
     if (content?.richText && Array.isArray(content.richText)) {
+      log?.info?.("[dingtalk] RichText message - msg.content: " + JSON.stringify(content).substring(0, 200));
       const parts: string[] = [];
 
       for (const item of content.richText) {
         if (item.msgType === "text" && item.content) {
           parts.push(item.content);
+        } else if (item.text) {
+          // DingTalk sometimes sends richText items as {text: "..."} without msgType wrapper
+          parts.push(item.text);
         } else if ((item.msgType === "picture" || item.pictureDownloadCode || item.downloadCode) && (item.downloadCode || item.pictureDownloadCode)) {
-          // Handle picture: msgType may be absent, check for downloadCode fields
           const downloadCode = item.downloadCode || item.pictureDownloadCode;
-          // Download the picture from richText message
           try {
             const robotCode = account.robotCode || account.clientId;
             const pictureResult = await downloadPicture(
-              account.clientId,
-              account.clientSecret,
-              robotCode,
-              downloadCode,
+              account.clientId!, account.clientSecret!, robotCode!, downloadCode,
             );
-
             if (pictureResult.filePath) {
               parts.push(`[图片: ${pictureResult.filePath}]`);
               log?.info?.("[dingtalk] Downloaded picture from richText: " + pictureResult.filePath);
@@ -194,69 +246,111 @@ async function processInboundMessage(
         }
       }
 
-      rawBody = parts.join("");
-      if (rawBody) {
-        log?.info?.("[dingtalk] Extracted from msg.content.richText: " + rawBody.substring(0, 100));
+      text = parts.join('');
+      if (text) {
+        log?.info?.("[dingtalk] Extracted from msg.content.richText: " + text.substring(0, 100));
       }
     }
   }
 
-  // Handle picture messages
-  if (!rawBody && msg.msgtype === 'picture') {
-    log?.info?.("[dingtalk] Picture message - msg.picture: " + JSON.stringify(msg.picture));
-    log?.info?.("[dingtalk] Picture message - msg.content: " + JSON.stringify((msg as any).content));
-    log?.info?.("[dingtalk] Full msg keys: " + Object.keys(msg).join(', '));
+  return { text };
+}
 
-    const content = (msg as any).content;
-    let downloadCode: string | undefined;
+/**
+ * Extract content from picture messages, returning the download code for media pipeline.
+ */
+function extractPictureContent(msg: DingTalkRobotMessage, log?: any): ExtractedMessage {
+  log?.info?.("[dingtalk] Picture message - msg.picture: " + JSON.stringify(msg.picture));
+  log?.info?.("[dingtalk] Picture message - msg.content: " + JSON.stringify(msg.content));
 
-    if (msg.picture?.downloadCode) {
-      downloadCode = msg.picture.downloadCode;
-    } else if (content?.downloadCode) {
-      downloadCode = content.downloadCode;
-    }
+  const content = msg.content;
+  let downloadCode: string | undefined;
 
-    if (downloadCode) {
-      log?.info?.("[dingtalk] Picture detected, downloadCode: " + downloadCode);
+  if (msg.picture?.downloadCode) {
+    downloadCode = msg.picture.downloadCode;
+  } else if (content?.downloadCode) {
+    downloadCode = content.downloadCode;
+  }
 
-      // Try to download the picture
-      try {
-        const robotCode = account.robotCode || account.clientId;
-        const pictureResult = await downloadPicture(
-          account.clientId,
-          account.clientSecret,
-          robotCode,
-          downloadCode,
-        );
-
-        if (pictureResult.error) {
-          rawBody = `[用户发送了图片，但下载失败: ${pictureResult.error}]`;
-          log?.warn?.("[dingtalk] Picture download failed: " + pictureResult.error);
-        } else if (pictureResult.filePath) {
-          rawBody = `[用户发送了图片]\n图片已保存到: ${pictureResult.filePath}`;
-          log?.info?.("[dingtalk] Picture downloaded successfully: " + pictureResult.filePath);
-
-          // Note: If Agent supports multimodal input, we could pass the base64 or file path
-          // For now, we just notify the agent that a picture was sent
-        } else {
-          rawBody = "[用户发送了图片，但无法获取下载链接]";
-        }
-      } catch (err) {
-        rawBody = `[用户发送了图片，下载时出错: ${err}]`;
-        log?.warn?.("[dingtalk] Error downloading picture: " + err);
+  if (downloadCode) {
+    log?.info?.("[dingtalk] Picture detected, downloadCode: " + downloadCode);
+    return {
+      text: '[用户发送了图片]',
+      mediaDownloadCode: downloadCode,
+      mediaType: 'image',
+      messageType: 'picture',
+    };
+  }
+
+  log?.info?.("[dingtalk] Picture msgtype but no downloadCode found");
+  return {
+    text: '[用户发送了图片(无法获取下载码)]',
+    messageType: 'picture',
+  };
+}
+
+async function processInboundMessage(
+  msg: DingTalkRobotMessage,
+  ctx: DingTalkMonitorContext,
+): Promise<void> {
+  const { account, cfg, log, setStatus } = ctx;
+  const runtime = getDingTalkRuntime();
+
+  const isDm = msg.conversationType === "1";
+  const isGroup = msg.conversationType === "2";
+
+  // Debug: log full message structure for debugging
+  if (msg.msgtype === 'richText' || msg.picture || (msg.atUsers && msg.atUsers.length > 0)) {
+    log?.info?.("[dingtalk-debug] Full message structure:");
+    log?.info?.("[dingtalk-debug]   msgtype: " + msg.msgtype);
+    log?.info?.("[dingtalk-debug]   text: " + JSON.stringify(msg.text));
+    log?.info?.("[dingtalk-debug]   richText: " + JSON.stringify(msg.richText));
+    log?.info?.("[dingtalk-debug]   picture: " + JSON.stringify(msg.picture));
+    log?.info?.("[dingtalk-debug]   atUsers: " + JSON.stringify(msg.atUsers));
+    log?.info?.("[dingtalk-debug]   RAW MESSAGE: " + JSON.stringify(msg).substring(0, 500));
+  }
+
+  // Extract message content using structured extractor
+  const extracted = await extractMessageContent(msg, account, log);
+
+  // Download media if present (picture/audio/video/file)
+  let mediaPath: string | undefined;
+  let mediaType: string | undefined;
+
+  if (extracted.mediaDownloadCode && account.clientId && account.clientSecret) {
+    const robotCode = account.robotCode || account.clientId;
+    try {
+      const result = await downloadMediaFile(
+        account.clientId,
+        account.clientSecret,
+        robotCode,
+        extracted.mediaDownloadCode,
+        extracted.mediaType,
+      );
+      if (result.filePath) {
+        mediaPath = result.filePath;
+        mediaType = result.mimeType || extracted.mediaType;
+        log?.info?.(`[dingtalk] Downloaded ${extracted.mediaType || 'media'}: ${result.filePath}`);
+      } else if (result.error) {
+        log?.warn?.(`[dingtalk] Media download failed: ${result.error}`);
       }
-    } else {
-      // Even if we can't get picture info, allow the message through
-      rawBody = "[用户发送了图片(无法获取下载码)]";
-      log?.info?.("[dingtalk] Picture msgtype but no downloadCode found");
+    } catch (err) {
+      log?.warn?.(`[dingtalk] Media download error: ${err}`);
     }
   }
 
-  if (!rawBody) {
-    log?.info?.("[dingtalk] Empty message body after all attempts, skipping. msgtype=" + msg.msgtype + ", hasText=" + !!msg.text + ", hasRichText=" + !!msg.richText + ", hasPicture=" + !!msg.picture);
+  let rawBody = extracted.text;
+
+  if (!rawBody && !mediaPath) {
+    log?.info?.("[dingtalk] Empty message body after all attempts, skipping. msgtype=" + msg.msgtype);
     return;
   }
 
+  // If we have media but no text, provide a placeholder
+  if (!rawBody && mediaPath) {
+    rawBody = `[${extracted.messageType}] 媒体文件已下载: ${mediaPath}`;
+  }
+
   // Handle quoted/replied messages: extract the quoted content and prepend it
   if (msg.text && (msg.text as any).isReplyMsg) {
     log?.info?.("[dingtalk] Message is a reply, full text object: " + JSON.stringify(msg.text));
@@ -334,8 +428,8 @@ async function processInboundMessage(
 
     if (userIds.length > 0 && account.clientId && account.clientSecret) {
       try {
-        // Batch query user info with 500ms timeout
-        const userInfoMap = await batchGetUserInfo(account.clientId, account.clientSecret, userIds, 500);
+        // Batch query user info (3s timeout — needs token fetch + API call)
+        const userInfoMap = await batchGetUserInfo(account.clientId, account.clientSecret, userIds, 3000);
 
         if (userInfoMap.size > 0) {
           // Build mention list: [@张三 @李四]
@@ -416,19 +510,44 @@ async function processInboundMessage(
     account,
   };
 
+  // Send thinking feedback (opt-in)
+  if (account.config.showThinking && msg.sessionWebhook) {
+    try {
+      await sendViaSessionWebhook(msg.sessionWebhook, '正在思考...');
+      log?.info?.('[dingtalk] Sent thinking indicator');
+    } catch (_) {
+      // fire-and-forget, don't block processing
+    }
+  }
+
   // Load actual config if cfg is a config manager
   let actualCfg = cfg;
   if (cfg && typeof cfg.loadConfig === "function") {
     try {
       actualCfg = await cfg.loadConfig();
-      console.warn("[dingtalk-debug] Loaded actual config, agents.defaults.model:", JSON.stringify(actualCfg?.agents?.defaults?.model, null, 2));
     } catch (err) {
-      console.warn("[dingtalk-debug] Failed to load config:", err);
+      log?.info?.("[dingtalk] Failed to load config: " + err);
     }
   }
 
+  // Check if the full Clawdbot Plugin SDK pipeline is available
+  const hasFullPipeline = !!(
+    runtime?.channel?.routing?.resolveAgentRoute &&
+    runtime?.channel?.reply?.finalizeInboundContext &&
+    runtime?.channel?.reply?.createReplyDispatcherWithTyping &&
+    runtime?.channel?.reply?.dispatchReplyFromConfig
+  );
+
   try {
-    if (runtime?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
+    if (hasFullPipeline) {
+      // Full SDK pipeline: route → session → envelope → dispatch
+      await dispatchWithFullPipeline({
+        runtime, msg, rawBody, account, cfg: actualCfg, sessionKey, isDm,
+        senderId, senderName, conversationId, replyTarget,
+        mediaPath, mediaType, log, setStatus,
+      });
+    } else if (runtime?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
+      // Fallback: existing buffered block dispatcher
       const ctxPayload = {
         Body: rawBody,
         RawBody: rawBody,
@@ -447,6 +566,9 @@ async function processInboundMessage(
         MessageSid: msg.msgId,
         OriginatingChannel: "dingtalk",
         OriginatingTo: "dingtalk:" + conversationId,
+        MediaPath: mediaPath,
+        MediaType: mediaType,
+        MediaUrl: mediaPath,
       };
 
       // Fire-and-forget: don't await to avoid blocking SDK callback during long agent runs
@@ -467,6 +589,9 @@ async function processInboundMessage(
       }).catch((err) => {
         log?.info?.("[dingtalk] Dispatch failed: " + err);
       });
+
+      // Record activity
+      runtime.channel?.activity?.record?.('dingtalk', account.accountId, 'message');
     } else {
       log?.info?.("[dingtalk] Runtime dispatch not available");
     }
@@ -475,12 +600,122 @@ async function processInboundMessage(
   }
 }
 
+/**
+ * Dispatch using the full Clawdbot Plugin SDK pipeline.
+ * Uses resolveAgentRoute → session → envelope → finalizeContext → dispatch.
+ */
+async function dispatchWithFullPipeline(params: {
+  runtime: any;
+  msg: DingTalkRobotMessage;
+  rawBody: string;
+  account: ResolvedDingTalkAccount;
+  cfg: any;
+  sessionKey: string;
+  isDm: boolean;
+  senderId: string;
+  senderName: string;
+  conversationId: string;
+  replyTarget: any;
+  mediaPath?: string;
+  mediaType?: string;
+  log?: any;
+  setStatus?: (update: Record<string, unknown>) => void;
+}): Promise<void> {
+  const { runtime: rt, msg, rawBody, account, cfg, isDm,
+          senderId, senderName, conversationId, replyTarget,
+          log, setStatus } = params;
+
+  // 1. Resolve agent route
+  const route = rt.channel.routing.resolveAgentRoute({
+    cfg,
+    channel: 'dingtalk',
+    accountId: account.accountId,
+    peer: { kind: isDm ? 'dm' : 'group', id: isDm ? senderId : conversationId },
+  });
+
+  // 2. Resolve store path
+  const storePath = rt.channel.session?.resolveStorePath?.(cfg?.session?.store, { agentId: route.agentId });
+
+  // 3. Get envelope format options
+  const envelopeOptions = rt.channel.reply?.resolveEnvelopeFormatOptions?.(cfg) ?? {};
+
+  // 4. Read previous timestamp for session continuity
+  const previousTimestamp = rt.channel.session?.readSessionUpdatedAt?.({ storePath, sessionKey: route.sessionKey });
+
+  // 5. Format inbound envelope
+  const fromLabel = isDm ? `${senderName} (${senderId})` : `${msg.conversationTitle || conversationId} - ${senderName}`;
+  const body = rt.channel.reply.formatInboundEnvelope?.({
+    channel: 'DingTalk', from: fromLabel, timestamp: msg.createAt, body: rawBody,
+    chatType: isDm ? 'direct' : 'group', sender: { name: senderName, id: senderId },
+    previousTimestamp, envelope: envelopeOptions,
+  }) ?? rawBody;
+
+  // 6. Finalize inbound context (includes media info)
+  const to = isDm ? `dingtalk:${senderId}` : `dingtalk:group:${conversationId}`;
+  const ctx = rt.channel.reply.finalizeInboundContext({
+    Body: body, RawBody: rawBody, CommandBody: rawBody, From: to, To: to,
+    SessionKey: route.sessionKey, AccountId: account.accountId,
+    ChatType: isDm ? 'direct' : 'group',
+    ConversationLabel: fromLabel,
+    GroupSubject: isDm ? undefined : (msg.conversationTitle || conversationId),
+    SenderName: senderName, SenderId: senderId,
+    Provider: 'dingtalk', Surface: 'dingtalk',
+    MessageSid: msg.msgId, Timestamp: msg.createAt,
+    MediaPath: params.mediaPath, MediaType: params.mediaType, MediaUrl: params.mediaPath,
+    CommandAuthorized: true,
+    OriginatingChannel: 'dingtalk', OriginatingTo: to,
+  });
+
+  // 7. Record inbound session
+  if (rt.channel.session?.recordInboundSession) {
+    await rt.channel.session.recordInboundSession({
+      storePath, sessionKey: ctx.SessionKey || route.sessionKey, ctx,
+      updateLastRoute: isDm ? { sessionKey: route.mainSessionKey, channel: 'dingtalk', to: senderId, accountId: account.accountId } : undefined,
+    });
+  }
+
+  // 8. Create typing-aware dispatcher
+  const { dispatcher, replyOptions, markDispatchIdle } = rt.channel.reply.createReplyDispatcherWithTyping({
+    responsePrefix: '',
+    deliver: async (payload: any) => {
+      try {
+        const textToSend = payload.markdown || payload.text;
+        if (!textToSend) return { ok: true };
+        await deliverReply(replyTarget, textToSend, log);
+        setStatus?.({ lastOutboundAt: Date.now() });
+        return { ok: true };
+      } catch (err: any) {
+        log?.info?.("[dingtalk] Reply delivery failed: " + err.message);
+        return { ok: false, error: err.message };
+      }
+    },
+  });
+
+  // 9. Dispatch reply from config
+  try {
+    await rt.channel.reply.dispatchReplyFromConfig({ ctx, cfg, dispatcher, replyOptions });
+  } finally {
+    markDispatchIdle();
+  }
+
+  // 10. Record activity
+  rt.channel?.activity?.record?.('dingtalk', account.accountId, 'message');
+}
+
 async function deliverReply(target: any, text: string, log?: any): Promise<void> {
   const now = Date.now();
   const chunkLimit = 2000;
   const messageFormat = target.account.config.messageFormat ?? "text";
-  // Support both "markdown" and "richtext" (they're equivalent for DingTalk)
-  const isMarkdown = messageFormat === "markdown" || messageFormat === "richtext";
+
+  // Determine if this message should use markdown format
+  let isMarkdown: boolean;
+  if (messageFormat === 'auto') {
+    isMarkdown = detectMarkdownContent(text);
+    log?.info?.("[dingtalk] Auto-detected format: " + (isMarkdown ? "markdown" : "text"));
+  } else {
+    // Support both "markdown" and "richtext" (they're equivalent for DingTalk)
+    isMarkdown = messageFormat === "markdown" || messageFormat === "richtext";
+  }
 
   // Convert markdown tables to text format (DingTalk doesn't support tables)
   let processedText = text;
@@ -603,6 +838,14 @@ function convertMarkdownTables(text: string): string {
   });
 }
 
+/**
+ * Detect if text contains markdown features worth rendering as markdown.
+ * Checks for headers, bold, code blocks, lists, blockquotes, links, and images.
+ */
+function detectMarkdownContent(text: string): boolean {
+  return /^#{1,6}\s|^\s*[-*+]\s|^\s*\d+\.\s|^\s*>|```|\*\*[^*]+\*\*|\[[^\]]+\]\([^)]+\)|!\[[^\]]*\]\([^)]+\)/m.test(text);
+}
+
 function isSenderAllowed(senderId: string, allowFrom: string[]): boolean {
   if (allowFrom.includes("*")) return true;
   const normalized = senderId.trim().toLowerCase();

package/src/types.ts

@@ -15,12 +15,15 @@ export interface DingTalkRobotMessage {
   sessionWebhook: string;
   robotCode: string;
   msgtype: string;
-  text?: { content: string };
+  text?: { content: string; isReplyMsg?: boolean; repliedMsg?: any };
   richText?: unknown;
   picture?: { downloadCode: string };
+  /** Generic content field used by audio/video/file message types */
+  content?: any;
   atUsers?: Array<{ dingtalkId: string; staffId?: string }>;
   isInAtList?: boolean;
   conversationTitle?: string;
+  senderPlatform?: string;
 }
 
 /** Resolved account for DingTalk */
@@ -36,6 +39,20 @@ export interface ResolvedDingTalkAccount {
   config: Record<string, any>;
 }
 
+/** Extracted message content from DingTalk */
+export interface ExtractedMessage {
+  /** Textual representation of the message */
+  text: string;
+  /** Download code for media (picture/audio/video/file) */
+  mediaDownloadCode?: string;
+  /** Media type category */
+  mediaType?: 'image' | 'audio' | 'video' | 'file';
+  /** Original file name (for file messages) */
+  mediaFileName?: string;
+  /** Original DingTalk msgtype */
+  messageType: string;
+}
+
 /** DingTalk channel config shape */
 export interface DingTalkChannelConfig {
   enabled?: boolean;
@@ -51,6 +68,7 @@ export interface DingTalkChannelConfig {
   groupAllowlist?: string[];
   requireMention?: boolean;
   textChunkLimit?: number;
-  messageFormat?: 'text' | 'markdown' | 'richtext';
+  messageFormat?: 'text' | 'markdown' | 'richtext' | 'auto';
+  showThinking?: boolean;
   [key: string]: unknown;
 }