@yaoyuanchao/dingtalk 1.4.20 → 1.5.0

package/CHANGELOG.md

@@ -5,6 +5,27 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [1.5.0] - 2026-01-31
+
+### 🎉 New Feature: Typing Indicator with Auto-Recall
+
+- **Typing Indicator** — When processing a message, automatically sends "⏳ 思考中..." which is silently recalled when the reply is ready. Much better UX than the old `showThinking` option.
+- **Message Recall APIs** — New functions in `api.ts`:
+  - `sendDMMessageWithKey()` — Send DM and return processQueryKey for recall
+  - `sendGroupMessageWithKey()` — Send group message and return processQueryKey
+  - `recallDMMessages()` — Batch recall DM messages
+  - `recallGroupMessages()` — Batch recall group messages
+  - `sendTypingIndicator()` — One-stop helper that returns a cleanup function
+
+### Configuration
+
+- `typingIndicator: false` — Disable typing indicator (default: enabled)
+- `typingIndicatorMessage: "xxx"` — Customize the thinking message
+
+### Changed
+
+- Deprecated `showThinking` option (still works as fallback if `typingIndicator` is explicitly disabled)
+
 ## [1.4.10] - 2026-01-30
 
 ### Fixed

package/package.json

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

package/src/api.ts

@@ -689,3 +689,267 @@ export function textToMarkdownFile(text: string, title?: string): { buffer: Buff
 
   return { buffer, fileName };
 }
+
+// ============================================================================
+// Message Recall (撤回) APIs
+// ============================================================================
+
+/**
+ * Send a DM message and return the processQueryKey for later recall
+ * This is an enhanced version that returns the message ID
+ */
+export async function sendDMMessageWithKey(params: {
+  clientId: string;
+  clientSecret: string;
+  robotCode: string;
+  userId: string;
+  text: string;
+  format?: 'text' | 'markdown';
+}): Promise<{ ok: boolean; processQueryKey?: string; error?: string }> {
+  try {
+    const token = await getDingTalkAccessToken(params.clientId, params.clientSecret);
+    const headers = { "x-acs-dingtalk-access-token": token };
+
+    const useMarkdown = params.format !== 'text';
+    const msgKey = useMarkdown ? 'sampleMarkdown' : 'sampleText';
+    const msgParam = useMarkdown
+      ? JSON.stringify({ title: 'AI', text: params.text })
+      : JSON.stringify({ content: params.text });
+
+    const res = await jsonPost(
+      `${DINGTALK_API_BASE}/robot/oToMessages/batchSend`,
+      {
+        robotCode: params.robotCode,
+        userIds: [params.userId],
+        msgKey,
+        msgParam,
+      },
+      headers,
+    );
+
+    if (res?.code || (res?.errcode && res.errcode !== 0)) {
+      console.warn(`[dingtalk] DM send error:`, res);
+      return { ok: false, error: res.message || res.errmsg };
+    }
+
+    return { 
+      ok: true, 
+      processQueryKey: res.processQueryKey 
+    };
+  } catch (err) {
+    console.warn(`[dingtalk] Error sending DM:`, err);
+    return { ok: false, error: String(err) };
+  }
+}
+
+/**
+ * Send a group message and return the processQueryKey for later recall
+ */
+export async function sendGroupMessageWithKey(params: {
+  clientId: string;
+  clientSecret: string;
+  robotCode: string;
+  conversationId: string;
+  text: string;
+  format?: 'text' | 'markdown';
+}): Promise<{ ok: boolean; processQueryKey?: string; error?: string }> {
+  try {
+    const token = await getDingTalkAccessToken(params.clientId, params.clientSecret);
+    const headers = { "x-acs-dingtalk-access-token": token };
+
+    const useMarkdown = params.format !== 'text';
+    const msgKey = useMarkdown ? 'sampleMarkdown' : 'sampleText';
+    const msgParam = useMarkdown
+      ? JSON.stringify({ title: 'AI', text: params.text })
+      : JSON.stringify({ content: params.text });
+
+    const res = await jsonPost(
+      `${DINGTALK_API_BASE}/robot/groupMessages/send`,
+      {
+        robotCode: params.robotCode,
+        openConversationId: params.conversationId,
+        msgKey,
+        msgParam,
+      },
+      headers,
+    );
+
+    if (res?.code || (res?.errcode && res.errcode !== 0)) {
+      console.warn(`[dingtalk] Group send error:`, res);
+      return { ok: false, error: res.message || res.errmsg };
+    }
+
+    return { 
+      ok: true, 
+      processQueryKey: res.processQueryKey 
+    };
+  } catch (err) {
+    console.warn(`[dingtalk] Error sending group message:`, err);
+    return { ok: false, error: String(err) };
+  }
+}
+
+/**
+ * Recall (撤回) DM messages
+ * Note: This is a "silent recall" - the message just disappears without notification
+ */
+export async function recallDMMessages(params: {
+  clientId: string;
+  clientSecret: string;
+  robotCode: string;
+  userId: string;
+  processQueryKeys: string[];
+}): Promise<{ ok: boolean; successKeys?: string[]; failedKeys?: Record<string, string>; error?: string }> {
+  try {
+    const token = await getDingTalkAccessToken(params.clientId, params.clientSecret);
+    const headers = { "x-acs-dingtalk-access-token": token };
+
+    const res = await jsonPost(
+      `${DINGTALK_API_BASE}/robot/otoMessages/batchRecall`,
+      {
+        robotCode: params.robotCode,
+        chatBotUserId: params.userId,
+        processQueryKeys: params.processQueryKeys,
+      },
+      headers,
+    );
+
+    if (res?.code || (res?.errcode && res.errcode !== 0)) {
+      console.warn(`[dingtalk] DM recall error:`, res);
+      return { ok: false, error: res.message || res.errmsg };
+    }
+
+    return { 
+      ok: true, 
+      successKeys: res.successResult,
+      failedKeys: res.failedResult,
+    };
+  } catch (err) {
+    console.warn(`[dingtalk] Error recalling DM:`, err);
+    return { ok: false, error: String(err) };
+  }
+}
+
+/**
+ * Recall (撤回) group messages
+ */
+export async function recallGroupMessages(params: {
+  clientId: string;
+  clientSecret: string;
+  robotCode: string;
+  conversationId: string;
+  processQueryKeys: string[];
+}): Promise<{ ok: boolean; successKeys?: string[]; failedKeys?: Record<string, string>; error?: string }> {
+  try {
+    const token = await getDingTalkAccessToken(params.clientId, params.clientSecret);
+    const headers = { "x-acs-dingtalk-access-token": token };
+
+    const res = await jsonPost(
+      `${DINGTALK_API_BASE}/robot/groupMessages/recall`,
+      {
+        robotCode: params.robotCode,
+        openConversationId: params.conversationId,
+        processQueryKeys: params.processQueryKeys,
+      },
+      headers,
+    );
+
+    if (res?.code || (res?.errcode && res.errcode !== 0)) {
+      console.warn(`[dingtalk] Group recall error:`, res);
+      return { ok: false, error: res.message || res.errmsg };
+    }
+
+    return { 
+      ok: true, 
+      successKeys: res.successResult,
+      failedKeys: res.failedResult,
+    };
+  } catch (err) {
+    console.warn(`[dingtalk] Error recalling group message:`, err);
+    return { ok: false, error: String(err) };
+  }
+}
+
+/**
+ * Typing indicator helper - sends a "thinking" message that will be recalled
+ * Returns a cleanup function to recall the message
+ */
+export async function sendTypingIndicator(params: {
+  clientId: string;
+  clientSecret: string;
+  robotCode: string;
+  userId?: string;
+  conversationId?: string;
+  message?: string;
+}): Promise<{ cleanup: () => Promise<void>; error?: string }> {
+  const typingMessage = params.message || "⏳ 思考中...";
+  
+  try {
+    if (params.userId) {
+      const result = await sendDMMessageWithKey({
+        clientId: params.clientId,
+        clientSecret: params.clientSecret,
+        robotCode: params.robotCode,
+        userId: params.userId,
+        text: typingMessage,
+        format: 'text',
+      });
+
+      if (!result.ok || !result.processQueryKey) {
+        return { 
+          cleanup: async () => {}, 
+          error: result.error || "Failed to send typing indicator" 
+        };
+      }
+
+      const processQueryKey = result.processQueryKey;
+      return {
+        cleanup: async () => {
+          await recallDMMessages({
+            clientId: params.clientId,
+            clientSecret: params.clientSecret,
+            robotCode: params.robotCode,
+            userId: params.userId!,
+            processQueryKeys: [processQueryKey],
+          });
+        }
+      };
+    }
+
+    if (params.conversationId) {
+      const result = await sendGroupMessageWithKey({
+        clientId: params.clientId,
+        clientSecret: params.clientSecret,
+        robotCode: params.robotCode,
+        conversationId: params.conversationId,
+        text: typingMessage,
+        format: 'text',
+      });
+
+      if (!result.ok || !result.processQueryKey) {
+        return { 
+          cleanup: async () => {}, 
+          error: result.error || "Failed to send typing indicator" 
+        };
+      }
+
+      const processQueryKey = result.processQueryKey;
+      return {
+        cleanup: async () => {
+          await recallGroupMessages({
+            clientId: params.clientId,
+            clientSecret: params.clientSecret,
+            robotCode: params.robotCode,
+            conversationId: params.conversationId!,
+            processQueryKeys: [processQueryKey],
+          });
+        }
+      };
+    }
+
+    return { cleanup: async () => {}, error: "Either userId or conversationId required" };
+  } catch (err) {
+    console.warn(`[dingtalk] Error sending typing indicator:`, err);
+    return { cleanup: async () => {}, error: String(err) };
+  }
+}

package/src/monitor.ts

@@ -1,5 +1,5 @@
 import type { DingTalkRobotMessage, ResolvedDingTalkAccount, ExtractedMessage } from "./types.js";
-import { sendViaSessionWebhook, sendMarkdownViaSessionWebhook, sendDingTalkRestMessage, batchGetUserInfo, downloadPicture, downloadMediaFile, cleanupOldMedia, uploadMediaFile, sendFileMessage, textToMarkdownFile } from "./api.js";
+import { sendViaSessionWebhook, sendMarkdownViaSessionWebhook, sendDingTalkRestMessage, batchGetUserInfo, downloadPicture, downloadMediaFile, cleanupOldMedia, uploadMediaFile, sendFileMessage, textToMarkdownFile, sendTypingIndicator } from "./api.js";
 import { getDingTalkRuntime } from "./runtime.js";
 
 // ============================================================================
@@ -853,11 +853,40 @@ async function dispatchMessage(params: {
   const runtime = getDingTalkRuntime();
   const isGroup = !isDm;
 
-  // Send thinking feedback (opt-in)
-  if (account.config.showThinking && replyTarget.sessionWebhook) {
+  // Typing indicator cleanup function (will be called after dispatch completes)
+  let typingCleanup: (() => Promise<void>) | null = null;
+
+  // Send typing indicator (recallable) if enabled
+  // This replaces the old showThinking feature with a better UX - the indicator disappears when reply arrives
+  if (account.config.typingIndicator !== false && account.clientId && account.clientSecret) {
+    try {
+      const typingMessage = account.config.typingIndicatorMessage || '⏳ 思考中...';
+      const robotCode = account.robotCode || account.clientId;
+      
+      const result = await sendTypingIndicator({
+        clientId: account.clientId,
+        clientSecret: account.clientSecret,
+        robotCode,
+        userId: isDm ? senderId : undefined,
+        conversationId: !isDm ? conversationId : undefined,
+        message: typingMessage,
+      });
+      
+      if (result.error) {
+        log?.info?.('[dingtalk] Typing indicator failed: ' + result.error);
+      } else {
+        typingCleanup = result.cleanup;
+        log?.info?.('[dingtalk] Typing indicator sent (will be recalled on reply)');
+      }
+    } catch (err) {
+      log?.info?.('[dingtalk] Typing indicator error: ' + err);
+    }
+  }
+  // Legacy: Send thinking feedback (opt-in, non-recallable) - only if typingIndicator is explicitly disabled
+  else if (account.config.showThinking && replyTarget.sessionWebhook) {
     try {
       await sendViaSessionWebhook(replyTarget.sessionWebhook, '正在思考...');
-      log?.info?.('[dingtalk] Sent thinking indicator');
+      log?.info?.('[dingtalk] Sent thinking indicator (legacy, non-recallable)');
     } catch (_) {
       // fire-and-forget, don't block processing
     }
@@ -881,6 +910,20 @@ async function dispatchMessage(params: {
     runtime?.channel?.reply?.dispatchReplyFromConfig
   );
 
+  // Track if we've already cleaned up the typing indicator
+  let typingCleaned = false;
+  const cleanupTyping = async () => {
+    if (typingCleanup && !typingCleaned) {
+      typingCleaned = true;
+      try {
+        await typingCleanup();
+        log?.info?.('[dingtalk] Typing indicator recalled');
+      } catch (err) {
+        log?.info?.('[dingtalk] Failed to recall typing indicator: ' + err);
+      }
+    }
+  };
+
   try {
     if (hasFullPipeline) {
       // Full SDK pipeline: route → session → envelope → dispatch
@@ -888,6 +931,7 @@ async function dispatchMessage(params: {
         runtime, msg, rawBody, account, cfg: actualCfg, sessionKey, isDm,
         senderId, senderName, conversationId, replyTarget,
         mediaPath, mediaType, log, setStatus,
+        onFirstReply: cleanupTyping,
       });
     } else if (runtime?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
       // Fallback: existing buffered block dispatcher
@@ -920,6 +964,9 @@ async function dispatchMessage(params: {
         cfg: actualCfg,
         dispatcherOptions: {
           deliver: async (payload: any) => {
+            // Recall typing indicator on first delivery
+            await cleanupTyping();
+            
             log?.info?.("[dingtalk] Deliver payload keys: " + Object.keys(payload || {}).join(',') + " text?=" + (typeof payload?.text) + " markdown?=" + (typeof payload?.markdown));
             const textToSend = resolveDeliverText(payload, log);
             if (textToSend) {
@@ -930,10 +977,13 @@ async function dispatchMessage(params: {
             }
           },
           onError: (err: any) => {
+            // Also cleanup on error
+            cleanupTyping().catch(() => {});
             log?.info?.("[dingtalk] Reply error: " + err);
           },
         },
       }).catch((err) => {
+        cleanupTyping().catch(() => {});
         log?.info?.("[dingtalk] Dispatch failed: " + err);
       });
 
@@ -941,8 +991,10 @@ async function dispatchMessage(params: {
       runtime.channel?.activity?.record?.('dingtalk', account.accountId, 'message');
     } else {
       log?.info?.("[dingtalk] Runtime dispatch not available");
+      await cleanupTyping();
     }
   } catch (err) {
+    await cleanupTyping();
     log?.info?.("[dingtalk] Dispatch error: " + err);
   }
 }
@@ -967,10 +1019,13 @@ async function dispatchWithFullPipeline(params: {
   mediaType?: string;
   log?: any;
   setStatus?: (update: Record<string, unknown>) => void;
+  onFirstReply?: () => Promise<void>;
 }): Promise<void> {
   const { runtime: rt, msg, rawBody, account, cfg, isDm,
           senderId, senderName, conversationId, replyTarget,
-          log, setStatus } = params;
+          log, setStatus, onFirstReply } = params;
+  
+  let firstReplyFired = false;
 
   // 1. Resolve agent route
   const route = rt.channel.routing.resolveAgentRoute({
@@ -1025,6 +1080,14 @@ async function dispatchWithFullPipeline(params: {
   const { dispatcher, replyOptions, markDispatchIdle } = rt.channel.reply.createReplyDispatcherWithTyping({
     responsePrefix: '',
     deliver: async (payload: any) => {
+      // Recall typing indicator on first delivery
+      if (!firstReplyFired && onFirstReply) {
+        firstReplyFired = true;
+        await onFirstReply().catch((err) => {
+          log?.info?.("[dingtalk] onFirstReply error: " + err);
+        });
+      }
+      
       try {
         log?.info?.("[dingtalk] Pipeline deliver payload keys: " + Object.keys(payload || {}).join(',') + " text?=" + (typeof payload?.text) + " markdown?=" + (typeof payload?.markdown));
         const textToSend = resolveDeliverText(payload, log);
@@ -1047,6 +1110,10 @@ async function dispatchWithFullPipeline(params: {
     await rt.channel.reply.dispatchReplyFromConfig({ ctx, cfg, dispatcher, replyOptions });
   } finally {
     markDispatchIdle();
+    // Ensure typing indicator is cleaned up even if no reply was sent
+    if (!firstReplyFired && onFirstReply) {
+      await onFirstReply().catch(() => {});
+    }
   }
 
   // 10. Record activity