@yaoyuanchao/dingtalk 1.7.5 → 1.7.7

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaoyuanchao/dingtalk",
-  "version": "1.7.5",
+  "version": "1.7.7",
   "type": "module",
   "description": "DingTalk channel plugin for ClawdBot/OpenClaw with Stream Mode support",
   "license": "MIT",

package/src/monitor.ts

@@ -46,6 +46,65 @@ function markMessageProcessed(messageId: string): void {
   }
 }
 
+// ============================================================================
+// Content-level dedup: DingTalk may re-deliver the same message with a NEW
+// msgId after Stream reconnect. Detect by sender + content hash + time window.
+// ============================================================================
+
+const CONTENT_DEDUP_WINDOW_MS = 2 * 60 * 1000; // 2 minutes
+const CONTENT_DEDUP_MAX = 200;
+const recentContentHashes = new Map<string, number>(); // hash → timestamp
+
+function simpleHash(str: string): string {
+  let h = 0;
+  for (let i = 0; i < str.length; i++) {
+    h = ((h << 5) - h + str.charCodeAt(i)) | 0;
+  }
+  return h.toString(36);
+}
+
+function isContentDuplicate(senderId: string, text: string, log?: any): boolean {
+  if (!senderId || !text || text.length < 4) return false;
+  const key = `${senderId}:${simpleHash(text)}:${text.length}`;
+  const prev = recentContentHashes.get(key);
+  if (prev && Date.now() - prev < CONTENT_DEDUP_WINDOW_MS) {
+    log?.info?.("[dingtalk] Content-level duplicate detected: sender=" + senderId + " len=" + text.length);
+    return true;
+  }
+  return false;
+}
+
+function markContentProcessed(senderId: string, text: string): void {
+  if (!senderId || !text || text.length < 4) return;
+  const key = `${senderId}:${simpleHash(text)}:${text.length}`;
+  recentContentHashes.set(key, Date.now());
+
+  // Evict old entries
+  if (recentContentHashes.size > CONTENT_DEDUP_MAX) {
+    const cutoff = Date.now() - CONTENT_DEDUP_WINDOW_MS;
+    for (const [k, ts] of recentContentHashes) {
+      if (ts < cutoff) recentContentHashes.delete(k);
+    }
+  }
+}
+
+// ============================================================================
+// Send Throttle - prevent hitting DingTalk's 40 QPS API rate limit.
+// Enforces a minimum interval between outbound API calls.
+// ============================================================================
+
+const SEND_THROTTLE_MS = 500; // 500ms minimum between sends
+let lastSendTime = 0;
+
+async function throttleSend(): Promise<void> {
+  const now = Date.now();
+  const elapsed = now - lastSendTime;
+  if (elapsed < SEND_THROTTLE_MS) {
+    await new Promise(resolve => setTimeout(resolve, SEND_THROTTLE_MS - elapsed));
+  }
+  lastSendTime = Date.now();
+}
+
 // ============================================================================
 // Message Cache - used to resolve quoted message content from originalMsgId
 // DingTalk Stream API does NOT include quoted content in reply callbacks;
@@ -198,6 +257,30 @@ const AGGREGATION_DELAY_MS = 2000; // 2 seconds - balance between UX and catchin
 
 const sessionQueues = new Map<string, Promise<void>>();
 const sessionQueueLastActivity = new Map<string, number>();
+
+// Track delivery activity per queue key to detect when the SDK's dispatch resolves
+// before the agent's full turn completes (e.g. followup turns running in background).
+// This supplements sessionQueues for the "busy" check.
+const DELIVER_ACTIVITY_GRACE_MS = 8000; // 8s after last delivery, consider idle
+const deliverActivityTimestamps = new Map<string, number>();
+
+function markDeliverActivity(queueKey: string): void {
+  deliverActivityTimestamps.set(queueKey, Date.now());
+}
+
+function hasActiveDelivery(queueKey: string): boolean {
+  const ts = deliverActivityTimestamps.get(queueKey);
+  if (!ts) return false;
+  if (Date.now() - ts > DELIVER_ACTIVITY_GRACE_MS) {
+    deliverActivityTimestamps.delete(queueKey);
+    return false;
+  }
+  return true;
+}
+
+function clearDeliverActivity(queueKey: string): void {
+  deliverActivityTimestamps.delete(queueKey);
+}
 const SESSION_QUEUE_TTL_MS = 5 * 60 * 1000; // 5 min
 
 const QUEUE_BUSY_PHRASES = [
@@ -286,8 +369,8 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
   });
 
   // Reconnection configuration
-  const HEARTBEAT_CHECK_MS = 30_000;     // Check connectivity every 30s
-  const HEARTBEAT_TIMEOUT_MS = 5 * 60 * 1000; // 5 min no activity = force reconnect
+  const HEARTBEAT_CHECK_MS = 15_000;     // Check connectivity every 15s
+  const HEARTBEAT_TIMEOUT_MS = 90_000;   // 90s no activity = force reconnect
   const RECONNECT_BASE_MS = 1_000;       // 1s initial backoff
   const RECONNECT_CAP_MS = 30_000;       // 30s max backoff
   let reconnectAttempt = 0;
@@ -354,7 +437,7 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
       log?.info?.("[dingtalk:" + account.accountId + "] Stream connected");
       setStatus?.({ running: true, lastStartAt: connectTime });
 
-      // Start heartbeat monitor: if no activity for 5 minutes, force disconnect to trigger reconnect.
+      // Start heartbeat monitor: if no activity for 90s, force disconnect to trigger reconnect.
       // The SDK's keepAlive ping/pong (8s interval) handles socket-level liveness and sets
       // client.connected=false on missed pongs, which our poll loop below detects.
       // This heartbeat is a secondary safety net for higher-level silent failures where
@@ -1256,6 +1339,13 @@ async function processInboundMessage(
     }
   }
 
+  // Content-level dedup: DingTalk may re-deliver the same message with a
+  // completely new msgId after Stream reconnect. Catch by sender + content hash.
+  if (isContentDuplicate(senderId, rawBody, log)) {
+    return;
+  }
+  markContentProcessed(senderId, rawBody);
+
   const sessionKey = "dingtalk:" + account.accountId + ":" + (isDm ? "dm" : "group") + ":" + conversationId;
 
   const replyTarget = {
@@ -1395,7 +1485,11 @@ async function dispatchMessage(params: {
   const { account, log } = ctx;
 
   const queueKey = `${account.accountId}:${conversationId}`;
-  const isQueueBusy = sessionQueues.has(queueKey);
+  // Check both the explicit queue AND recent delivery activity.
+  // The SDK's dispatchReplyFromConfig may resolve before the agent's full turn
+  // completes (followup turns run in background), clearing the queue entry
+  // while deliveries are still happening.
+  const isQueueBusy = sessionQueues.has(queueKey) || hasActiveDelivery(queueKey);
 
   // If queue is busy, add emotion reaction on user's message to indicate queued
   let queueAckCleanup: (() => Promise<void>) | null = null;
@@ -1437,11 +1531,13 @@ async function dispatchMessage(params: {
       // Clean up only if this is still the latest task
       if (sessionQueues.get(queueKey) === currentTask) {
         sessionQueues.delete(queueKey);
+        log?.info?.("[dingtalk] Queue entry removed for " + queueKey + " (deliverActive=" + hasActiveDelivery(queueKey) + ")");
       }
     });
 
   sessionQueues.set(queueKey, currentTask);
   sessionQueueLastActivity.set(queueKey, Date.now());
+  log?.info?.("[dingtalk] Queue entry set for " + queueKey + " (wasQueueBusy=" + isQueueBusy + ")");
 
   // Don't await — fire-and-forget so message buffering and SDK callback stay responsive
 }
@@ -1604,11 +1700,14 @@ async function dispatchMessageInternal(params: {
 
       // Await dispatch so per-session queue waits for reply delivery to complete
       // before starting the next queued message.
+      const fallbackQueueKey = `${account.accountId}:${conversationId}`;
       await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
         ctx: ctxPayload,
         cfg: actualCfg,
         dispatcherOptions: {
           deliver: async (payload: any) => {
+            // Track delivery activity for queue busy detection
+            markDeliverActivity(fallbackQueueKey);
             // Recall typing indicator on first delivery
             await cleanupTyping();
 
@@ -1757,9 +1856,12 @@ async function dispatchWithFullPipeline(params: {
   }
 
   // 8. Create typing-aware dispatcher
+  const deliverQueueKey = `${account.accountId}:${conversationId}`;
   const { dispatcher, replyOptions, markDispatchIdle } = rt.channel.reply.createReplyDispatcherWithTyping({
     responsePrefix: '',
     deliver: async (payload: any) => {
+      // Track delivery activity for queue busy detection
+      markDeliverActivity(deliverQueueKey);
       // Recall typing indicator on first delivery
       if (!firstReplyFired && onFirstReply) {
         firstReplyFired = true;
@@ -1787,14 +1889,24 @@ async function dispatchWithFullPipeline(params: {
 
   // 9. Dispatch reply from config
   try {
+    log?.info?.("[dingtalk] dispatchReplyFromConfig started for " + deliverQueueKey);
     await rt.channel.reply.dispatchReplyFromConfig({ ctx, cfg, dispatcher, replyOptions });
+    log?.info?.("[dingtalk] dispatchReplyFromConfig completed for " + deliverQueueKey);
   } finally {
+    // OpenClaw 2026.4+ moved dispatcher.markComplete() + waitForIdle() out of
+    // dispatchReplyFromConfig into the withReplyDispatcher wrapper. Since we call
+    // dispatchReplyFromConfig directly (not through withReplyDispatcher), we must
+    // do this ourselves to ensure all pending deliveries drain before returning.
+    try {
+      if (typeof dispatcher.markComplete === 'function') {
+        dispatcher.markComplete();
+      }
+      await dispatcher.waitForIdle();
+      log?.info?.("[dingtalk] dispatcher.waitForIdle completed for " + deliverQueueKey);
+    } catch (err) {
+      log?.info?.("[dingtalk] dispatcher settle error: " + err);
+    }
     markDispatchIdle();
-    // Don't recall typing here — dispatchReplyFromConfig resolves when dispatch
-    // is *initiated*, not when the agent finishes. The agent may still be doing
-    // tool calls for many minutes before producing text. The deliver callback
-    // above handles recall on first delivery. If the agent crashes without
-    // replying, the emoji reaction simply stays — acceptable tradeoff.
   }
 
   // 10. Record activity
@@ -1921,6 +2033,7 @@ async function deliverReply(target: any, text: string, log?: any): Promise<void>
     if (target.sessionWebhook && now < (target.sessionWebhookExpiry - 60_000)) {
       for (let attempt = 1; attempt <= maxRetries; attempt++) {
         try {
+          await throttleSend();
           log?.info?.("[dingtalk] Using sessionWebhook (attempt " + attempt + "/" + maxRetries + "), format=" + messageFormat);
           log?.info?.("[dingtalk] Sending text (" + chunk.length + " chars): " + chunk.substring(0, 200));
           let sendResult: { ok: boolean; errcode?: number; errmsg?: string; processQueryKey?: string };
@@ -1962,6 +2075,7 @@ async function deliverReply(target: any, text: string, log?: any): Promise<void>
     // Fallback to REST API if webhook failed after all retries
     if (!webhookSuccess && target.account.clientId && target.account.clientSecret) {
       try {
+        await throttleSend();
         log?.info?.("[dingtalk] SessionWebhook unavailable, using REST API fallback");
         const restResult = await sendDingTalkRestMessage({
           clientId: target.account.clientId,