@soimy/dingtalk 3.1.4 → 3.2.0

package/src/inbound-handler.ts

@@ -2,14 +2,10 @@ import axios from "axios";
 import { normalizeAllowFrom, isSenderAllowed, isSenderGroupAllowed } from "./access-control";
 import { getAccessToken } from "./auth";
 import {
-  cleanupCardCache,
   createAICard,
   finishAICard,
   formatContentForCard,
-  getActiveCardIdByTarget,
-  getCardById,
   isCardInTerminalState,
-  streamAICard,
 } from "./card-service";
 import { resolveGroupConfig } from "./config";
 import { formatGroupMembers, noteGroupMember } from "./group-members-store";
@@ -24,6 +20,7 @@ import { getDingTalkRuntime } from "./runtime";
 import { sendBySession, sendMessage } from "./send-service";
 import type { DingTalkConfig, HandleDingTalkMessageParams, MediaFile } from "./types";
 import { AICardStatus } from "./types";
+import { acquireSessionLock } from "./session-lock";
 import { formatDingTalkErrorPayloadLog, maskSensitiveData } from "./utils";
 
 const DEFAULT_PROACTIVE_HINT_COOLDOWN_HOURS = 24;
@@ -148,8 +145,11 @@ export async function downloadMedia(
     const contentType = mediaResponse.headers["content-type"] || "application/octet-stream";
     const buffer = Buffer.from(mediaResponse.data as ArrayBuffer);
 
-    // Keep inbound media handling consistent with other channels.
-    const saved = await rt.channel.media.saveMediaBuffer(buffer, contentType, "inbound");
+    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");
     log?.debug?.(`[DingTalk] Media saved: ${saved.path}`);
     return { path: saved.path, mimeType: saved.contentType ?? contentType };
   } catch (err: any) {
@@ -185,9 +185,6 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
 
   log?.debug?.("[DingTalk] Full Inbound Data:", JSON.stringify(maskSensitiveData(data)));
 
-  // Clean up old terminal cards opportunistically on inbound traffic.
-  cleanupCardCache();
-
   // 1) Ignore self messages from bot.
   if (data.senderId === data.chatbotUserId || data.senderStaffId === data.chatbotUserId) {
     log?.debug?.("[DingTalk] Ignoring robot self-message");
@@ -326,6 +323,35 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     agentId: route.agentId,
   });
 
+  const to = isDirect ? senderId : groupId;
+
+  // 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.
+  const useCardMode = dingtalkConfig.messageType === "card";
+  let currentAICard = undefined;
+  let lastCardContent = "";
+
+  if (useCardMode) {
+    try {
+      log?.debug?.(
+        `[DingTalk][AICard] conversationType=${data.conversationType}, conversationId=${to}`,
+      );
+      const aiCard = await createAICard(dingtalkConfig, to, log);
+      if (aiCard) {
+        currentAICard = aiCard;
+      } else {
+        log?.warn?.(
+          "[DingTalk] Failed to create AI card (returned null), fallback to text/markdown.",
+        );
+      }
+    } catch (err: any) {
+      log?.warn?.(
+        `[DingTalk] Failed to create AI card: ${err.message}, fallback to text/markdown.`,
+      );
+    }
+  }
+
   let mediaPath: string | undefined;
   let mediaType: string | undefined;
   if (content.mediaPath && dingtalkConfig.robotCode) {
@@ -366,7 +392,6 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     envelope: envelopeOptions,
   });
 
-  const to = isDirect ? senderId : groupId;
   const ctx = rt.channel.reply.finalizeInboundContext({
     Body: body,
     RawBody: content.text,
@@ -407,199 +432,218 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
 
   log?.info?.(`[DingTalk] Inbound: from=${senderName} text="${content.text.slice(0, 50)}..."`);
 
-  // 3) Select response mode (card vs markdown).
-  const useCardMode = dingtalkConfig.messageType === "card";
-  let currentAICard = undefined;
-  let lastCardContent = "";
-
-  if (useCardMode) {
-    const targetKey = `${accountId}:${to}`;
-    const existingCardId = getActiveCardIdByTarget(targetKey);
-    const existingCard = existingCardId ? getCardById(existingCardId) : undefined;
-
-    // Reuse active non-terminal card to keep one card per conversation.
-    if (existingCard && !isCardInTerminalState(existingCard.state)) {
-      currentAICard = existingCard;
-      log?.debug?.("[DingTalk] Reusing existing active AI card for this conversation.");
-    } else {
+  // Serialize dispatchReply + card finalize per session to prevent the runtime
+  // from receiving concurrent dispatch calls on the same session key, which
+  // causes empty replies for all but the first caller.
+  const releaseSessionLock = await acquireSessionLock(route.sessionKey);
+  try {
+    // 4) Optional "thinking..." feedback for non-card mode.
+    if (dingtalkConfig.showThinking !== false) {
       try {
-        const aiCard = await createAICard(dingtalkConfig, to, data, accountId, log);
-        if (aiCard) {
-          currentAICard = aiCard;
+        const thinkingText = "🤔 思考中，请稍候...";
+        if (useCardMode && currentAICard) {
+          log?.debug?.("[DingTalk] AI Card in thinking state, skipping thinking message send.");
         } else {
-          log?.warn?.(
-            "[DingTalk] Failed to create AI card (returned null), fallback to text/markdown.",
-          );
+          lastCardContent = thinkingText;
+          const sendResult = await sendMessage(dingtalkConfig, to, thinkingText, {
+            sessionWebhook,
+            atUserId: !isDirect ? senderId : null,
+            log,
+            card: currentAICard,
+          });
+          if (!sendResult.ok) {
+            throw new Error(sendResult.error || "Thinking message send failed");
+          }
         }
       } catch (err: any) {
-        log?.warn?.(
-          `[DingTalk] Failed to create AI card: ${err.message}, fallback to text/markdown.`,
-        );
+        log?.debug?.(`[DingTalk] Thinking message failed: ${err.message}`);
+        if (err?.response?.data !== undefined) {
+          log?.debug?.(formatDingTalkErrorPayloadLog("inbound.thinkingMessage", err.response.data));
+        }
       }
     }
-  }
 
-  // 4) Optional "thinking..." feedback for non-card mode.
-  if (dingtalkConfig.showThinking !== false) {
+    let queuedFinal: unknown;
     try {
-      const thinkingText = "🤔 思考中，请稍候...";
-      if (useCardMode && currentAICard) {
-        log?.debug?.("[DingTalk] AI Card in thinking state, skipping thinking message send.");
-      } else {
-        lastCardContent = thinkingText;
-        await sendMessage(dingtalkConfig, to, thinkingText, {
-          sessionWebhook,
-          atUserId: !isDirect ? senderId : null,
-          log,
-          accountId,
-        });
-      }
-    } catch (err: any) {
-      log?.debug?.(`[DingTalk] Thinking message failed: ${err.message}`);
-      if (err?.response?.data !== undefined) {
-        log?.debug?.(formatDingTalkErrorPayloadLog("inbound.thinkingMessage", err.response.data));
-      }
-    }
-  }
-
-  const { queuedFinal } = await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
-    ctx,
-    cfg,
-    dispatcherOptions: {
-      responsePrefix: "",
-      deliver: async (payload: any, info?: { kind: string }) => {
-        try {
-          const textToSend = payload.markdown || payload.text;
-          if (!textToSend) {
-            return;
-          }
-
-          if (typeof textToSend === "string" && isUnhandledStopReasonText(textToSend)) {
-            log?.warn?.(`[DingTalk] Suppressed stop reason from outbound chat content: ${textToSend}`);
-            return;
-          }
-
-          if (useCardMode && currentAICard && info?.kind === "final") {
-            lastCardContent = textToSend;
-            return;
-          }
-
-          // Tool outputs are rendered into card stream as a separate formatted block.
-          if (useCardMode && currentAICard && info?.kind === "tool") {
+      const dispatchResult = await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx,
+        cfg,
+        dispatcherOptions: {
+          responsePrefix: "",
+          deliver: async (payload: any, info?: { kind: string }) => {
+            try {
+              const textToSend = payload.markdown || payload.text;
+              if (!textToSend) {
+                return;
+              }
+
+              if (typeof textToSend === "string" && isUnhandledStopReasonText(textToSend)) {
+                log?.warn?.(`[DingTalk] Suppressed stop reason from outbound chat content: ${textToSend}`);
+                return;
+              }
+
+              if (useCardMode && currentAICard && info?.kind === "final") {
+                lastCardContent = textToSend;
+                return;
+              }
+
+              if (useCardMode && currentAICard && info?.kind === "tool") {
+                if (isCardInTerminalState(currentAICard.state)) {
+                  log?.debug?.(
+                    `[DingTalk] Skipping tool stream update because card is terminal: state=${currentAICard.state}`,
+                  );
+                  return;
+                }
+
+                log?.info?.(
+                  `[DingTalk] Tool result received, streaming to AI Card: ${textToSend.slice(0, 100)}`,
+                );
+                const toolText = formatContentForCard(textToSend, "tool");
+                if (toolText) {
+                  const sendResult = await sendMessage(dingtalkConfig, to, toolText, {
+                    sessionWebhook,
+                    atUserId: !isDirect ? senderId : null,
+                    log,
+                    card: currentAICard,
+                    cardUpdateMode: "append",
+                  });
+                  if (!sendResult.ok) {
+                    throw new Error(sendResult.error || "Tool stream send failed");
+                  }
+                  lastCardContent = currentAICard.lastStreamedContent || toolText;
+                  return;
+                }
+              }
+
+              lastCardContent = textToSend;
+              const sendResult = await sendMessage(dingtalkConfig, to, textToSend, {
+                sessionWebhook,
+                atUserId: !isDirect ? senderId : null,
+                log,
+                card: currentAICard,
+              });
+              if (!sendResult.ok) {
+                throw new Error(sendResult.error || "Reply send failed");
+              }
+            } catch (err: any) {
+              log?.error?.(`[DingTalk] Reply failed: ${err.message}`);
+              if (err?.response?.data !== undefined) {
+                log?.error?.(formatDingTalkErrorPayloadLog("inbound.replyDeliver", err.response.data));
+              }
+              throw err;
+            }
+          },
+        },
+        replyOptions: {
+          onReasoningStream: async (payload: any) => {
+            if (!useCardMode || !currentAICard) {
+              return;
+            }
             if (isCardInTerminalState(currentAICard.state)) {
               log?.debug?.(
-                `[DingTalk] Skipping tool stream update because card is terminal: state=${currentAICard.state}`,
+                `[DingTalk] Skipping thinking stream update because card is terminal: state=${currentAICard.state}`,
               );
               return;
             }
-
-            log?.info?.(
-              `[DingTalk] Tool result received, streaming to AI Card: ${textToSend.slice(0, 100)}`,
-            );
-            const toolText = formatContentForCard(textToSend, "tool");
-            if (toolText) {
-              await streamAICard(currentAICard, toolText, false, log);
+            const thinkingText = formatContentForCard(payload.text, "thinking");
+            if (!thinkingText) {
               return;
             }
-          }
-
-          lastCardContent = textToSend;
-          await sendMessage(dingtalkConfig, to, textToSend, {
-            sessionWebhook,
-            atUserId: !isDirect ? senderId : null,
-            log,
-            accountId,
-          });
-        } catch (err: any) {
-          log?.error?.(`[DingTalk] Reply failed: ${err.message}`);
-          if (err?.response?.data !== undefined) {
-            log?.error?.(formatDingTalkErrorPayloadLog("inbound.replyDeliver", err.response.data));
-          }
-          throw err;
-        }
-      },
-    },
-    replyOptions: {
-      // Real-time reasoning stream support for card mode.
-      onReasoningStream: async (payload: any) => {
-        if (!useCardMode || !currentAICard) {
-          return;
+            try {
+              const sendResult = await sendMessage(dingtalkConfig, to, thinkingText, {
+                sessionWebhook,
+                atUserId: !isDirect ? senderId : null,
+                log,
+                card: currentAICard,
+                cardUpdateMode: "append",
+              });
+              if (!sendResult.ok) {
+                throw new Error(sendResult.error || "Thinking stream send failed");
+              }
+            } catch (err: any) {
+              log?.debug?.(`[DingTalk] Thinking stream update failed: ${err.message}`);
+              if (err?.response?.data !== undefined) {
+                log?.debug?.(formatDingTalkErrorPayloadLog("inbound.thinkingStream", err.response.data));
+              }
+            }
+          },
+        },
+      });
+      queuedFinal = dispatchResult?.queuedFinal;
+    } catch (dispatchErr: any) {
+      if (useCardMode && currentAICard && !isCardInTerminalState(currentAICard.state)) {
+        try {
+          await finishAICard(currentAICard, "❌ 处理失败", log);
+        } catch (cardCloseErr: any) {
+          log?.debug?.(`[DingTalk] Failed to finalize card after dispatch error: ${cardCloseErr.message}`);
+          currentAICard.state = AICardStatus.FAILED;
+          currentAICard.lastUpdated = Date.now();
         }
+      }
+      throw dispatchErr;
+    }
+
+    // 5) Finalize card stream if card mode is active.
+    if (useCardMode && currentAICard) {
+      try {
         if (isCardInTerminalState(currentAICard.state)) {
           log?.debug?.(
-            `[DingTalk] Skipping thinking stream update because card is terminal: state=${currentAICard.state}`,
+            `[DingTalk] Skipping AI Card finalization because card is terminal: state=${currentAICard.state}`,
           );
           return;
         }
-        const thinkingText = formatContentForCard(payload.text, "thinking");
-        if (!thinkingText) {
-          return;
-        }
-        try {
-          await streamAICard(currentAICard, thinkingText, false, log);
-        } catch (err: any) {
-          log?.debug?.(`[DingTalk] Thinking stream update failed: ${err.message}`);
-          if (err?.response?.data !== undefined) {
-            log?.debug?.(formatDingTalkErrorPayloadLog("inbound.thinkingStream", err.response.data));
+
+        const isNonEmptyString = (value: any): boolean =>
+          typeof value === "string" && value.trim().length > 0;
+
+        const hasLastCardContent = isNonEmptyString(lastCardContent);
+        const hasQueuedFinalString = isNonEmptyString(queuedFinal);
+
+        if (hasLastCardContent || hasQueuedFinalString) {
+          const finalContentCandidate =
+            hasLastCardContent && typeof lastCardContent === "string"
+              ? lastCardContent
+              : typeof queuedFinal === "string"
+                ? queuedFinal
+                : "";
+          if (isUnhandledStopReasonText(finalContentCandidate)) {
+            log?.warn?.(
+              `[DingTalk] Suppressed stop reason from AI Card final content: ${finalContentCandidate}`,
+            );
+            currentAICard.state = AICardStatus.FINISHED;
+            currentAICard.lastUpdated = Date.now();
+            return;
+          }
+          const finalContent = finalContentCandidate;
+          await finishAICard(currentAICard, finalContent, log);
+        } else {
+          const lastStreamed = currentAICard.lastStreamedContent;
+          if (typeof lastStreamed === "string" && lastStreamed.trim().length > 0) {
+            await finishAICard(currentAICard, lastStreamed, log);
+          } else {
+            const defaultFinalContent = "✅ Done";
+            log?.debug?.(
+              "[DingTalk] No textual content was produced; finalizing AI Card with default completion content.",
+            );
+            await finishAICard(currentAICard, defaultFinalContent, log);
           }
         }
-      },
-    },
-  });
-
-  // 5) Finalize card stream if card mode is active.
-  if (useCardMode && currentAICard) {
-    try {
-      if (isCardInTerminalState(currentAICard.state)) {
-        log?.debug?.(
-          `[DingTalk] Skipping AI Card finalization because card is terminal: state=${currentAICard.state}`,
-        );
-        return;
-      }
-
-      const isNonEmptyString = (value: any): boolean =>
-        typeof value === "string" && value.trim().length > 0;
-
-      const hasLastCardContent = isNonEmptyString(lastCardContent);
-      const hasQueuedFinalString = isNonEmptyString(queuedFinal);
-
-      if (hasLastCardContent || hasQueuedFinalString) {
-        const finalContentCandidate =
-          hasLastCardContent && typeof lastCardContent === "string"
-            ? lastCardContent
-            : typeof queuedFinal === "string"
-              ? queuedFinal
-              : "";
-        if (isUnhandledStopReasonText(finalContentCandidate)) {
-          log?.warn?.(
-            `[DingTalk] Suppressed stop reason from AI Card final content: ${finalContentCandidate}`,
-          );
-          currentAICard.state = AICardStatus.FINISHED;
-          currentAICard.lastUpdated = Date.now();
-          return;
+      } catch (err: any) {
+        log?.debug?.(`[DingTalk] AI Card finalization failed: ${err.message}`);
+        if (err?.response?.data !== undefined) {
+          log?.debug?.(formatDingTalkErrorPayloadLog("inbound.cardFinalize", err.response.data));
         }
-        const finalContent = finalContentCandidate;
-        await finishAICard(currentAICard, finalContent, log);
-      } else {
-        const defaultFinalContent = "✅ Done";
-        log?.debug?.(
-          "[DingTalk] No textual content was produced; finalizing AI Card with default completion content.",
-        );
-        await finishAICard(currentAICard, defaultFinalContent, log);
-      }
-    } catch (err: any) {
-      log?.debug?.(`[DingTalk] AI Card finalization failed: ${err.message}`);
-      if (err?.response?.data !== undefined) {
-        log?.debug?.(formatDingTalkErrorPayloadLog("inbound.cardFinalize", err.response.data));
-      }
-      try {
-        if (currentAICard.state !== AICardStatus.FINISHED) {
-          currentAICard.state = AICardStatus.FAILED;
-          currentAICard.lastUpdated = Date.now();
+        try {
+          if (currentAICard.state !== AICardStatus.FINISHED) {
+            currentAICard.state = AICardStatus.FAILED;
+            currentAICard.lastUpdated = Date.now();
+          }
+        } catch (stateErr: any) {
+          log?.debug?.(`[DingTalk] Failed to update card state to FAILED: ${stateErr.message}`);
         }
-      } catch (stateErr: any) {
-        log?.debug?.(`[DingTalk] Failed to update card state to FAILED: ${stateErr.message}`);
       }
     }
+  } finally {
+    releaseSessionLock();
   }
 }