@soimy/dingtalk 3.2.0 → 3.4.0

package/src/channel.ts

@@ -1,22 +1,51 @@
 import { randomUUID } from "node:crypto";
-import { DWClient, TOPIC_ROBOT } from "dingtalk-stream";
-import type {
-  ChannelMessageActionAdapter,
-  OpenClawConfig,
-} from "openclaw/plugin-sdk";
+import { DWClient, TOPIC_CARD, TOPIC_ROBOT } from "dingtalk-stream";
+import type { ChannelMessageActionAdapter, OpenClawConfig } from "openclaw/plugin-sdk";
 import * as pluginSdk from "openclaw/plugin-sdk";
 import { getAccessToken } from "./auth";
-import { createAICard, streamAICard, finishAICard } from "./card-service";
-import { getConfig, isConfigured, resolveRelativePath, stripTargetPrefix } from "./config";
+import { analyzeCardCallback } from "./card-callback-service";
+import {
+  createAICard,
+  streamAICard,
+  finishAICard,
+  finalizeActiveCardsForAccount,
+  recoverPendingCardsForAccount,
+} from "./card-service";
+import {
+  getConfig,
+  isConfigured,
+  mergeAccountWithDefaults,
+  resolveGroupConfig,
+  resolveRelativePath,
+  stripTargetPrefix,
+} from "./config";
 import { DingTalkConfigSchema } from "./config-schema.js";
 import { ConnectionManager } from "./connection-manager";
 import { isMessageProcessed, markMessageProcessed } from "./dedup";
+import {
+  isFeedbackLearningAutoApplyEnabled,
+  isFeedbackLearningEnabled,
+  recordExplicitFeedbackLearning,
+} from "./feedback-learning-service";
 import { handleDingTalkMessage } from "./inbound-handler";
 import { getLogger } from "./logger-context";
 import { prepareMediaInput, resolveOutboundMediaType } from "./media-utils";
 import { dingtalkOnboardingAdapter } from "./onboarding.js";
-import { resolveOriginalPeerId } from "./peer-id-registry";
-import { sendMessage, sendProactiveMedia, sendBySession, uploadMedia } from "./send-service";
+import { resolveOriginalPeerId, preloadPeerIdsFromSessions } from "./peer-id-registry";
+import { getDingTalkRuntime } from "./runtime";
+import {
+  sendMessage,
+  sendProactiveMedia,
+  sendProactiveTextOrMarkdown,
+  sendBySession,
+  uploadMedia,
+} from "./send-service";
+import {
+  listDingTalkDirectoryGroups,
+  listDingTalkDirectoryUsers,
+  normalizeResolvedDingTalkTarget,
+} from "./targeting/target-directory-adapter";
+import { looksLikeDingTalkTargetId, normalizeDingTalkTarget } from "./targeting/target-input";
 import type {
   DingTalkInboundMessage,
   GatewayStartContext,
@@ -24,12 +53,94 @@ import type {
   ConnectionManagerConfig,
   DingTalkChannelPlugin,
   ResolvedAccount,
+  StreamClientFactory,
 } from "./types";
 import { ConnectionState } from "./types";
-import { cleanupOrphanedTempFiles, formatDingTalkErrorPayloadLog, getCurrentTimestamp } from "./utils";
+import {
+  cleanupOrphanedTempFiles,
+  createResolve4FallbackLookup,
+  formatDingTalkConnectionErrorLog,
+  formatDingTalkErrorPayloadLog,
+  getCurrentTimestamp,
+} from "./utils";
+
+type InstrumentedDWClient = {
+  getEndpoint?: () => Promise<unknown>;
+  _connect?: () => Promise<unknown>;
+  config?: Record<string, unknown> & { endpoint?: { endpoint?: string } | string };
+  dw_url?: string;
+};
+
+function attachConnectionErrorContext(
+  err: unknown,
+  stage: "connect.open" | "connect.websocket",
+  endpoint?: string,
+): void {
+  if (!err || typeof err !== "object") {
+    return;
+  }
+  const target = err as Record<string, unknown>;
+  if (typeof target.dingtalkConnectionStage !== "string") {
+    target.dingtalkConnectionStage = stage;
+  }
+  if (endpoint && typeof target.dingtalkConnectionEndpoint !== "string") {
+    target.dingtalkConnectionEndpoint = endpoint;
+  }
+}
+
+function getInstrumentedEndpoint(client: InstrumentedDWClient): string | undefined {
+  if (typeof client.dw_url === "string" && client.dw_url.length > 0) {
+    return client.dw_url;
+  }
+
+  const endpointConfig = client.config?.endpoint;
+  if (typeof endpointConfig === "string") {
+    return endpointConfig;
+  }
+  if (
+    endpointConfig &&
+    typeof endpointConfig === "object" &&
+    typeof endpointConfig.endpoint === "string"
+  ) {
+    return endpointConfig.endpoint;
+  }
+  return undefined;
+}
+
+function instrumentConnectionStages(client: DWClient): void {
+  const instrumented = client as unknown as InstrumentedDWClient;
+  if (
+    typeof instrumented.getEndpoint !== "function" ||
+    typeof instrumented._connect !== "function"
+  ) {
+    return;
+  }
+
+  const originalGetEndpoint = instrumented.getEndpoint.bind(instrumented);
+  const originalSocketConnect = instrumented._connect.bind(instrumented);
+
+  instrumented.getEndpoint = async () => {
+    try {
+      return await originalGetEndpoint();
+    } catch (err) {
+      attachConnectionErrorContext(err, "connect.open");
+      throw err;
+    }
+  };
+
+  instrumented._connect = async () => {
+    try {
+      return await originalSocketConnect();
+    } catch (err) {
+      attachConnectionErrorContext(err, "connect.websocket", getInstrumentedEndpoint(instrumented));
+      throw err;
+    }
+  };
+}
 
 const INFLIGHT_TTL_MS = 5 * 60 * 1000; // 5 min safety net for hung handlers
 const processingDedupKeys = new Map<string, number>(); // key → timestamp when acquired
+export const CHANNEL_INFLIGHT_NAMESPACE_POLICY = "memory-only" as const;
 const inboundCountersByAccount = new Map<
   string,
   {
@@ -142,28 +253,36 @@ const dingtalkMessageActions: ChannelMessageActionAdapter = {
     const config = getConfig(cfg, accountId ?? undefined);
 
     if (hasMedia && mediaInput) {
-      const mediaPath = resolveRelativePath(mediaInput);
-      const mediaType = resolveOutboundMediaType({
-        mediaType: requestedMediaType ?? undefined,
-        mediaPath,
-        asVoice,
-      });
-      const result = await sendProactiveMedia(config, target, mediaPath, mediaType, {
-        log,
-        accountId: accountId ?? undefined,
-      });
+      let preparedMedia;
+      try {
+        preparedMedia = await prepareMediaInput(mediaInput, log, config.mediaUrlAllowlist);
+        const mediaPath = preparedMedia.cleanup
+          ? preparedMedia.path
+          : resolveRelativePath(preparedMedia.path);
+        const mediaType = resolveOutboundMediaType({
+          mediaType: requestedMediaType ?? undefined,
+          mediaPath,
+          asVoice,
+        });
+        const result = await sendProactiveMedia(config, target, mediaPath, mediaType, {
+          log,
+          accountId: accountId ?? undefined,
+        });
 
-      if (!result.ok) {
-        throw new Error(result.error || "send media failed");
-      }
+        if (!result.ok) {
+          throw new Error(result.error || "send media failed");
+        }
 
-      return pluginSdk.jsonResult({
-        ok: true,
-        to: target,
-        mediaType,
-        messageId: result.messageId ?? null,
-        result: result.data ?? null,
-      });
+        return pluginSdk.jsonResult({
+          ok: true,
+          to: target,
+          mediaType,
+          messageId: result.messageId ?? null,
+          result: result.data ?? null,
+        });
+      } finally {
+        await preparedMedia?.cleanup?.();
+      }
     }
 
     if (asVoice) {
@@ -231,7 +350,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       const config = getConfig(cfg);
       const id = accountId || "default";
       const account = config.accounts?.[id];
-      const resolvedConfig = account || config;
+      const resolvedConfig = account ? mergeAccountWithDefaults(config, account) : config;
       const configured = Boolean(resolvedConfig.clientId && resolvedConfig.clientSecret);
       return {
         accountId: id,
@@ -262,7 +381,16 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
     }),
   },
   groups: {
-    resolveRequireMention: ({ cfg }: any): boolean => getConfig(cfg).groupPolicy !== "open",
+    resolveRequireMention: ({ cfg, groupId }: any): boolean => {
+      const config = getConfig(cfg);
+      if (groupId) {
+        const groupCfg = resolveGroupConfig(config, groupId);
+        if (groupCfg?.requireMention !== undefined) {
+          return groupCfg.requireMention;
+        }
+      }
+      return config.groupPolicy !== "open";
+    },
     resolveGroupIntroHint: ({ groupId, groupChannel }: any): string | undefined => {
       const parts = [`conversationId=${groupId}`];
       if (groupChannel) {
@@ -272,12 +400,20 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
     },
   },
   messaging: {
-    normalizeTarget: (raw: string) => (raw ? raw.replace(/^(dingtalk|dd|ding):/i, "") : undefined),
+    normalizeTarget: (raw: string) => (raw ? normalizeDingTalkTarget(raw) : undefined),
     targetResolver: {
-      looksLikeId: (id: string): boolean => /^[\w+\-/=]+$/.test(id),
-      hint: "<conversationId>",
+      looksLikeId: (raw: string, normalized?: string): boolean =>
+        looksLikeDingTalkTargetId(raw, normalized),
+      hint: "<displayName|conversationId|user:staffId|user:+861...>",
     },
   },
+  directory: {
+    self: async () => null,
+    listGroups: async (params) => listDingTalkDirectoryGroups(params),
+    listGroupsLive: async (params) => listDingTalkDirectoryGroups(params),
+    listPeers: async (params) => listDingTalkDirectoryUsers(params),
+    listPeersLive: async (params) => listDingTalkDirectoryUsers(params),
+  },
   actions: dingtalkMessageActions,
   outbound: {
     deliveryMode: "direct" as const,
@@ -289,26 +425,38 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           error: new Error("DingTalk message requires --to <conversationId>"),
         };
       }
-      const { targetId } = stripTargetPrefix(trimmed);
-      const resolved = resolveOriginalPeerId(targetId);
-      return { ok: true as const, to: resolved };
+      return { ok: true as const, to: normalizeResolvedDingTalkTarget(trimmed) };
     },
     sendText: async ({ cfg, to, text, accountId, log }: any) => {
       const config = getConfig(cfg, accountId);
+      const rt = getDingTalkRuntime();
+      const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
+        agentId: accountId,
+      });
       try {
-        const result = await sendMessage(config, to, text, { log, accountId });
+        const result = await sendMessage(config, to, text, {
+          log,
+          accountId,
+          storePath,
+          conversationId: to,
+        });
         getLogger()?.debug?.(`[DingTalk] sendText: "${text}" result: ${JSON.stringify(result)}`);
         if (!result.ok) {
           throw new Error(result.error || "sendText failed");
         }
         const data = result.data as any;
         const messageId = String(data?.processQueryKey || data?.messageId || randomUUID());
+        const meta =
+          result.data || result.tracking
+            ? {
+                ...(result.data ? { data: result.data as unknown as Record<string, unknown> } : {}),
+                ...(result.tracking ? { tracking: result.tracking } : {}),
+              }
+            : undefined;
         return {
           channel: "dingtalk",
           messageId,
-          meta: result.data
-            ? { data: result.data as unknown as Record<string, unknown> }
-            : undefined,
+          meta,
         };
       } catch (err: any) {
         if (err?.response?.data !== undefined) {
@@ -334,6 +482,10 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       log,
     }: any) => {
       const config = getConfig(cfg, accountId);
+      const rt = getDingTalkRuntime();
+      const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
+        agentId: accountId,
+      });
       if (!config.clientId) {
         throw new Error("DingTalk not configured");
       }
@@ -362,12 +514,17 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           preparedMedia = await prepareMediaInput(rawMediaPath, log, config.mediaUrlAllowlist);
         } catch (err: any) {
           if (err?.response?.data !== undefined) {
-            log?.error?.(formatDingTalkErrorPayloadLog("outbound.sendMedia.prepare", err.response.data));
+            log?.error?.(
+              formatDingTalkErrorPayloadLog("outbound.sendMedia.prepare", err.response.data),
+            );
           }
           const errorCode = typeof err?.code === "string" ? `[${err.code}] ` : "";
-          throw new Error(`remote media preparation failed: ${errorCode}${err?.message || "unknown error"}`, {
-            cause: err,
-          });
+          throw new Error(
+            `remote media preparation failed: ${errorCode}${err?.message || "unknown error"}`,
+            {
+              cause: err,
+            },
+          );
         }
 
         const actualMediaPath = preparedMedia.cleanup
@@ -388,10 +545,14 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           result = await sendProactiveMedia(config, to, actualMediaPath, mediaType, {
             log,
             accountId,
+            storePath,
+            conversationId: to,
           });
         } catch (err: any) {
           if (err?.response?.data !== undefined) {
-            log?.error?.(formatDingTalkErrorPayloadLog("outbound.sendMedia.send", err.response.data));
+            log?.error?.(
+              formatDingTalkErrorPayloadLog("outbound.sendMedia.send", err.response.data),
+            );
           }
           throw new Error(`proactive media send failed: ${err?.message || "unknown error"}`, {
             cause: err,
@@ -439,118 +600,228 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
       if (!config.clientId || !config.clientSecret) {
         throw new Error("DingTalk clientId and clientSecret are required");
       }
+      let accountStorePath: string | undefined;
+      try {
+        const rt = getDingTalkRuntime();
+        accountStorePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
+          agentId: account.accountId,
+        });
+      } catch {
+        accountStorePath = undefined;
+      }
 
       ctx.log?.info?.(`[${account.accountId}] Initializing DingTalk Stream client...`);
 
+      // Preload known peer IDs from sessions so outbound delivery (e.g. cron
+      // jobs that fire immediately after startup) can resolve the original
+      // case-sensitive conversationId before any inbound message has arrived.
+      preloadPeerIdsFromSessions();
+      ctx.log?.debug?.(`[${account.accountId}] Peer ID registry preloaded from sessions`);
+
       cleanupOrphanedTempFiles(ctx.log);
+      try {
+        const recovered = await recoverPendingCardsForAccount(
+          config,
+          account.accountId,
+          accountStorePath,
+          ctx.log,
+        );
+        if (recovered > 0) {
+          ctx.log?.info?.(
+            `[${account.accountId}] Recovered and finalized ${recovered} unfinished card(s) from previous runtime`,
+          );
+        }
+      } catch (err: any) {
+        ctx.log?.warn?.(
+          `[${account.accountId}] Failed to recover unfinished cards: ${err.message}`,
+        );
+      }
 
       const useConnectionManager = config.useConnectionManager ?? true;
 
-      const client = new DWClient({
-        clientId: config.clientId,
-        clientSecret: config.clientSecret,
-        debug: config.debug || false,
-        keepAlive: !useConnectionManager,
-      });
+      // Factory that creates a fresh DWClient with the TOPIC_ROBOT callback
+      // already registered. Each client captures its own reference for
+      // socketCallBackResponse so acks are sent on the correct socket.
+      // ConnectionManager uses this to create new clients during warm
+      // reconnection, minimizing the message-loss window when the DingTalk
+      // server initiates a disconnect for load balancing.
+      const createStreamClient: StreamClientFactory = () => {
+        const c = new DWClient({
+          clientId: config.clientId,
+          clientSecret: config.clientSecret,
+          debug: config.debug || false,
+          keepAlive: config.keepAlive ?? !useConnectionManager,
+        });
+        (c as any).sslopts = {
+          ...(c as any).sslopts,
+          lookup: createResolve4FallbackLookup(ctx.log, account.accountId),
+        };
 
-      (client as any).config.autoReconnect = !useConnectionManager;
+        instrumentConnectionStages(c);
 
-      client.registerCallbackListener(TOPIC_ROBOT, async (res: any) => {
-        const messageId = res.headers?.messageId;
-        const stats = getInboundCounters(account.accountId);
-        stats.received += 1;
-        const acknowledge = () => {
-          if (!messageId) {
-            return;
-          }
+        (c as any).config.autoReconnect = !useConnectionManager;
+
+        c.registerCallbackListener(TOPIC_ROBOT, async (res: any) => {
+          const messageId = res.headers?.messageId;
+          const stats = getInboundCounters(account.accountId);
+          stats.received += 1;
+          const acknowledge = () => {
+            if (!messageId) {
+              return;
+            }
+            try {
+              c.socketCallBackResponse(messageId, { success: true });
+              stats.acked += 1;
+            } catch (ackError: any) {
+              ctx.log?.warn?.(
+                `[${account.accountId}] Failed to acknowledge callback ${messageId}: ${ackError.message}`,
+              );
+            }
+          };
           try {
-            client.socketCallBackResponse(messageId, { success: true });
-            stats.acked += 1;
-          } catch (ackError: any) {
-            ctx.log?.warn?.(
-              `[${account.accountId}] Failed to acknowledge callback ${messageId}: ${ackError.message}`,
-            );
-          }
-        };
-        try {
-          const data = JSON.parse(res.data) as DingTalkInboundMessage;
-
-          // Message deduplication key is bot-scoped to avoid cross-account conflicts.
-          const robotKey = config.robotCode || config.clientId || account.accountId;
-          const msgId = data.msgId || messageId;
-          const dedupKey = msgId ? `${robotKey}:${msgId}` : undefined;
-
-          if (!dedupKey) {
-            ctx.log?.warn?.(`[${account.accountId}] No message ID available for deduplication`);
-            stats.noMessageId += 1;
-            await handleDingTalkMessage({
-              cfg,
-              accountId: account.accountId,
-              data,
-              sessionWebhook: data.sessionWebhook,
-              log: ctx.log,
-              dingtalkConfig: config,
-            });
-            stats.processed += 1;
-            acknowledge();
-            if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
-              logInboundCounters(ctx.log, account.accountId, "periodic");
+            const data = JSON.parse(res.data) as DingTalkInboundMessage;
+
+            const robotKey = config.robotCode || config.clientId || account.accountId;
+            const msgId = data.msgId || messageId;
+            const dedupKey = msgId ? `${robotKey}:${msgId}` : undefined;
+
+            if (!dedupKey) {
+              ctx.log?.warn?.(`[${account.accountId}] No message ID available for deduplication`);
+              stats.noMessageId += 1;
+              acknowledge();
+              await handleDingTalkMessage({
+                cfg,
+                accountId: account.accountId,
+                data,
+                sessionWebhook: data.sessionWebhook,
+                log: ctx.log,
+                dingtalkConfig: config,
+              });
+              stats.processed += 1;
+              if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
+                logInboundCounters(ctx.log, account.accountId, "periodic");
+              }
+              return;
+            }
+
+            if (isMessageProcessed(dedupKey)) {
+              ctx.log?.debug?.(`[${account.accountId}] Skipping duplicate message: ${dedupKey}`);
+              stats.dedupSkipped += 1;
+              acknowledge();
+              logInboundCounters(ctx.log, account.accountId, "dedup-skipped");
+              return;
+            }
+
+            const inflightSince = processingDedupKeys.get(dedupKey);
+            if (inflightSince !== undefined) {
+              if (Date.now() - inflightSince > INFLIGHT_TTL_MS) {
+                ctx.log?.warn?.(
+                  `[${account.accountId}] Releasing stale in-flight lock for ${dedupKey} (held ${Date.now() - inflightSince}ms > TTL ${INFLIGHT_TTL_MS}ms)`,
+                );
+                processingDedupKeys.delete(dedupKey);
+              } else {
+                ctx.log?.debug?.(
+                  `[${account.accountId}] Skipping in-flight duplicate message: ${dedupKey}`,
+                );
+                stats.inflightSkipped += 1;
+                acknowledge();
+                logInboundCounters(ctx.log, account.accountId, "inflight-skipped");
+                return;
+              }
             }
-            return;
-          }
 
-          if (isMessageProcessed(dedupKey)) {
-            ctx.log?.debug?.(`[${account.accountId}] Skipping duplicate message: ${dedupKey}`);
-            stats.dedupSkipped += 1;
             acknowledge();
-            logInboundCounters(ctx.log, account.accountId, "dedup-skipped");
-            return;
+            processingDedupKeys.set(dedupKey, Date.now());
+            try {
+              await handleDingTalkMessage({
+                cfg,
+                accountId: account.accountId,
+                data,
+                sessionWebhook: data.sessionWebhook,
+                log: ctx.log,
+                dingtalkConfig: config,
+              });
+              stats.processed += 1;
+              markMessageProcessed(dedupKey);
+              if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
+                logInboundCounters(ctx.log, account.accountId, "periodic");
+              }
+            } finally {
+              processingDedupKeys.delete(dedupKey);
+            }
+          } catch (error: any) {
+            stats.failed += 1;
+            logInboundCounters(ctx.log, account.accountId, "failed");
+            ctx.log?.error?.(`[${account.accountId}] Error processing message: ${error.message}`);
           }
+        });
 
-          const inflightSince = processingDedupKeys.get(dedupKey);
-          if (inflightSince !== undefined) {
-            if (Date.now() - inflightSince > INFLIGHT_TTL_MS) {
+        c.registerCallbackListener(TOPIC_CARD, async (res: any) => {
+          const messageId = res.headers?.messageId;
+          const acknowledge = () => {
+            if (!messageId) {
+              return;
+            }
+            try {
+              c.socketCallBackResponse(messageId, { success: true });
+            } catch (ackError: any) {
               ctx.log?.warn?.(
-                `[${account.accountId}] Releasing stale in-flight lock for ${dedupKey} (held ${Date.now() - inflightSince}ms > TTL ${INFLIGHT_TTL_MS}ms)`,
-              );
-              processingDedupKeys.delete(dedupKey);
-            } else {
-              ctx.log?.debug?.(
-                `[${account.accountId}] Skipping in-flight duplicate message: ${dedupKey}`,
+                `[${account.accountId}] Failed to acknowledge card callback ${messageId}: ${ackError.message}`,
               );
-              stats.inflightSkipped += 1;
-              // Do not acknowledge in-flight duplicates before the original handler succeeds.
-              // If the original later fails, early-acking the duplicate can suppress server redelivery.
-              logInboundCounters(ctx.log, account.accountId, "inflight-skipped");
-              return;
             }
-          }
+          };
 
-          processingDedupKeys.set(dedupKey, Date.now());
           try {
-            await handleDingTalkMessage({
-              cfg,
-              accountId: account.accountId,
-              data,
-              sessionWebhook: data.sessionWebhook,
-              log: ctx.log,
-              dingtalkConfig: config,
-            });
-            stats.processed += 1;
-            markMessageProcessed(dedupKey);
-            acknowledge();
-            if (stats.received % INBOUND_COUNTER_LOG_EVERY === 0) {
-              logInboundCounters(ctx.log, account.accountId, "periodic");
+            const payload = JSON.parse(res.data);
+            const analysis = analyzeCardCallback(payload);
+            ctx.log?.info?.(
+              `[${account.accountId}] [DingTalk][CardCallback] action=${analysis.summary} raw=${JSON.stringify(payload)}`,
+            );
+
+            if (analysis.feedbackTarget && analysis.feedbackAckText) {
+              recordExplicitFeedbackLearning({
+                enabled: isFeedbackLearningEnabled(config),
+                autoApply: isFeedbackLearningAutoApplyEnabled(config),
+                storePath: accountStorePath,
+                accountId: account.accountId,
+                targetId: analysis.feedbackTarget,
+                feedbackType: analysis.actionId === "feedback_up" ? "feedback_up" : "feedback_down",
+                userId: analysis.userId,
+                processQueryKey: analysis.processQueryKey,
+                noteTtlMs: config.learningNoteTtlMs ?? config.feedbackLearningNoteTtlMs,
+              });
+              try {
+                await sendProactiveTextOrMarkdown(
+                  config,
+                  analysis.feedbackTarget,
+                  analysis.feedbackAckText,
+                  {
+                    accountId: account.accountId,
+                    log: ctx.log,
+                  },
+                );
+                ctx.log?.info?.(
+                  `[${account.accountId}] [DingTalk][CardCallback] feedback ack sent to ${analysis.feedbackTarget}`,
+                );
+              } catch (sendErr: any) {
+                ctx.log?.warn?.(
+                  `[${account.accountId}] [DingTalk][CardCallback] Failed to send feedback ack: ${sendErr?.message || String(sendErr)}`,
+                );
+              }
             }
+          } catch (error: any) {
+            ctx.log?.error?.(
+              `[${account.accountId}] [DingTalk][CardCallback] Failed to parse callback: ${error.message}`,
+            );
           } finally {
-            processingDedupKeys.delete(dedupKey);
+            acknowledge();
           }
-        } catch (error: any) {
-          stats.failed += 1;
-          logInboundCounters(ctx.log, account.accountId, "failed");
-          ctx.log?.error?.(`[${account.accountId}] Error processing message: ${error.message}`);
-        }
-      });
+        });
+
+        return c;
+      };
+
+      const client = createStreamClient();
 
       // Guard against duplicate stop paths (abort signal + explicit stop).
       let stopped = false;
@@ -566,6 +837,17 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         }
         stopped = true;
         ctx.log?.info?.(`[${account.accountId}] Stopping DingTalk Stream client...`);
+        void finalizeActiveCardsForAccount(
+          config,
+          account.accountId,
+          "⚠️ 服务正在重启，当前回复已中断。请重新发送你的问题。",
+          accountStorePath,
+          ctx.log,
+        ).catch((err: any) => {
+          ctx.log?.debug?.(
+            `[${account.accountId}] Failed to finalize active cards during stop: ${err.message}`,
+          );
+        });
         if (useConnectionManager) {
           connectionManager?.stop();
         } else {
@@ -627,7 +909,14 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
             await nativeStopPromise;
           }
         } catch (err: any) {
-          ctx.log?.error?.(`[${account.accountId}] Failed to establish connection: ${err.message}`);
+          ctx.log?.error?.(
+            formatDingTalkConnectionErrorLog(
+              // Use connect.open as base scope; instrumentation can override to connect.websocket
+              "connect.open",
+              err,
+              `[${account.accountId}] Failed to establish connection: ${err.message}`,
+            ) ?? `[${account.accountId}] Failed to establish connection: ${err.message}`,
+          );
           ctx.setStatus({
             ...ctx.getStatus(),
             running: false,
@@ -649,6 +938,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         maxDelay: config.maxReconnectDelay ?? 60000,
         jitter: config.reconnectJitter ?? 0.3,
         maxReconnectCycles: config.maxReconnectCycles,
+        reconnectDeadlineMs: config.reconnectDeadlineMs,
         onStateChange: (state: ConnectionState, error?: string) => {
           if (stopped) {
             return;
@@ -700,6 +990,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         account.accountId,
         connectionConfig,
         ctx.log,
+        createStreamClient,
       );
 
       try {
@@ -722,7 +1013,14 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           );
         }
       } catch (err: any) {
-        ctx.log?.error?.(`[${account.accountId}] Failed to establish connection: ${err.message}`);
+        ctx.log?.error?.(
+          formatDingTalkConnectionErrorLog(
+            // Use connect.open as base scope; instrumentation can override to connect.websocket
+            "connect.open",
+            err,
+            `[${account.accountId}] Failed to establish connection: ${err.message}`,
+          ) ?? `[${account.accountId}] Failed to establish connection: ${err.message}`,
+        );
 
         ctx.setStatus({
           ...ctx.getStatus(),
@@ -743,6 +1041,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
     defaultRuntime: {
       accountId: "default",
       running: false,
+      lastEventAt: null,
       lastStartAt: null,
       lastStopAt: null,
       lastError: null,
@@ -788,18 +1087,24 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
         return { ok: false, error: error.message };
       }
     },
-    buildAccountSnapshot: ({ account, runtime, snapshot, probe }: any) => ({
-      accountId: account.accountId,
-      name: account.name,
-      enabled: account.enabled,
-      configured: account.configured,
-      clientId: account.config?.clientId ?? null,
-      running: runtime?.running ?? snapshot?.running ?? false,
-      lastStartAt: runtime?.lastStartAt ?? snapshot?.lastStartAt ?? null,
-      lastStopAt: runtime?.lastStopAt ?? snapshot?.lastStopAt ?? null,
-      lastError: runtime?.lastError ?? snapshot?.lastError ?? null,
-      probe,
-    }),
+    buildAccountSnapshot: ({ account, runtime, snapshot, probe }: any) => {
+      const running = runtime?.running ?? snapshot?.running ?? false;
+      const persistedLastEventAt = runtime?.lastEventAt ?? snapshot?.lastEventAt ?? null;
+
+      return {
+        accountId: account.accountId,
+        name: account.name,
+        enabled: account.enabled,
+        configured: account.configured,
+        clientId: account.config?.clientId ?? null,
+        running,
+        lastEventAt: running ? getCurrentTimestamp() : persistedLastEventAt,
+        lastStartAt: runtime?.lastStartAt ?? snapshot?.lastStartAt ?? null,
+        lastStopAt: runtime?.lastStopAt ?? snapshot?.lastStopAt ?? null,
+        lastError: runtime?.lastError ?? snapshot?.lastError ?? null,
+        probe,
+      };
+    },
   },
 };