@soimy/dingtalk 3.5.0 → 3.5.2

package/src/inbound-handler.ts

@@ -1,43 +1,26 @@
-import axios from "axios";
+import fs from "node:fs";
+import axios from "./http-client";
 import { normalizeAllowFrom, isSenderAllowed, resolveGroupAccess } from "./access-control";
 import { buildAgentSessionKey, resolveSubAgentRoute, dispatchSubAgents } from "./targeting/agent-routing";
 import { classifyAckReactionEmoji } from "./ack-reaction-classifier";
 import { attachNativeAckReaction } from "./ack-reaction-service";
 import { createDynamicAckReactionController } from "./ack-reaction/dynamic-ack-reaction-controller";
-import { extractAttachmentText } from "./attachment-text-extractor";
+import { extractAttachmentText } from "./messaging/attachment-text-extractor";
 import { getAccessToken } from "./auth";
 import { createAICard, finishAICard, isCardInTerminalState } from "./card-service";
+import { handleInboundCommandDispatch } from "./command/inbound-command-dispatch-service";
 import { resolveAckReactionSetting, resolveGroupConfig, resolveRobotCode } from "./config";
+import { AICardStatus } from "./types";
+import {
+  isCardRunStopRequested,
+  registerCardRun,
+  removeCardRun,
+} from "./card/card-run-registry";
 import {
-  applyManualTargetLearningRule,
-  applyManualTargetsLearningRule,
-  applyManualGlobalLearningRule,
-  applyManualSessionLearningNote,
-  applyTargetSetLearningRule,
   buildLearningContextBlock,
-  createOrUpdateTargetSet,
-  deleteManualRule,
-  disableManualRule,
   isLearningEnabled,
-  listLearningTargetSets,
-  listScopedLearningRules,
-  resolveManualForcedReply,
 } from "./feedback-learning-service";
-import { formatGroupMembers, noteGroupMember } from "./group-members-store";
-import {
-  formatLearnAppliedReply,
-  formatLearnCommandHelp,
-  formatLearnDeletedReply,
-  formatLearnDisabledReply,
-  formatLearnListReply,
-  formatOwnerOnlyDeniedReply,
-  formatOwnerStatusReply,
-  formatTargetSetSavedReply,
-  formatWhereAmIReply,
-  formatWhoAmIReply,
-  isLearningOwner,
-  parseLearnCommand,
-} from "./learning-command-service";
+import { formatGroupMembers, noteGroupMember } from "./targeting/group-members-store";
 import { setCurrentLogger } from "./logger-context";
 import { prepareMediaInput, resolveOutboundMediaType } from "./media-utils";
 import {
@@ -57,21 +40,11 @@ import {
   clearProactiveRiskObservationsForTest,
   getProactiveRiskObservationForAny,
 } from "./proactive-risk-registry";
-import { downloadGroupFile, getUnionIdByStaffId, resolveQuotedFile } from "./quoted-file-service";
+import { downloadGroupFile, getUnionIdByStaffId, resolveQuotedFile } from "./messaging/quoted-file-service";
 import { createReplyStrategy } from "./reply-strategy";
 import type { DeliverPayload } from "./reply-strategy";
 import { getDingTalkRuntime } from "./runtime";
 import { sendBySession, sendMessage, sendProactiveMedia } from "./send-service";
-import {
-  formatSessionAliasBoundReply,
-  formatSessionAliasClearedReply,
-  formatSessionAliasReply,
-  formatSessionAliasSetReply,
-  formatSessionAliasUnboundReply,
-  formatSessionAliasValidationErrorReply,
-  parseSessionCommand,
-  validateSessionAlias,
-} from "./session-command-service";
 import { acquireSessionLock } from "./session-lock";
 import {
   clearSessionPeerOverride,
@@ -83,8 +56,7 @@ import {
   upsertObservedGroupTarget,
   upsertObservedUserTarget,
 } from "./targeting/target-directory-store";
-import { AICardStatus } from "./types";
-import type { DingTalkConfig, HandleDingTalkMessageParams, MediaFile } from "./types";
+import type { DingTalkConfig, HandleDingTalkMessageParams, Logger, MediaFile } from "./types";
 import { formatDingTalkErrorPayloadLog, getErrorMessage, getErrorResponseData, maskSensitiveData } from "./utils";
 import { isAbortRequestText } from "openclaw/plugin-sdk/reply-runtime";
 
@@ -93,6 +65,72 @@ const MIN_THINKING_REACTION_VISIBLE_MS = 1200;
 const MAX_DYNAMIC_ACK_DISPOSE_WAIT_MS = 500;
 const ATTACHMENT_TEXT_PREFIX = "[附件内容摘录]";
 const proactiveHintLastSentAt = new Map<string, number>();
+const sessionReasoningLevelCache = new Map<string, {
+  updatedAt?: number;
+  reasoningLevel?: string;
+}>();
+type ReplyMode = "card" | "markdown";
+
+function readSessionReasoningLevel(params: {
+  storePath?: string;
+  sessionKey: string;
+  sessionUpdatedAt?: number;
+  log?: Logger;
+}): string | undefined {
+  if (!params.storePath || !params.sessionKey) {
+    return undefined;
+  }
+  const cacheKey = `${params.storePath}:${params.sessionKey}`;
+  const cached = sessionReasoningLevelCache.get(cacheKey);
+  if (
+    cached
+    && params.sessionUpdatedAt !== undefined
+    && cached.updatedAt === params.sessionUpdatedAt
+  ) {
+    return cached.reasoningLevel;
+  }
+  try {
+    const raw = fs.readFileSync(params.storePath, "utf8");
+    const parsed = JSON.parse(raw) as Record<string, { reasoningLevel?: unknown }>;
+    const value = parsed?.[params.sessionKey]?.reasoningLevel;
+    const reasoningLevel = typeof value === "string" ? value.trim().toLowerCase() : undefined;
+    sessionReasoningLevelCache.set(cacheKey, {
+      updatedAt: params.sessionUpdatedAt,
+      reasoningLevel,
+    });
+    return reasoningLevel;
+  } catch (err: unknown) {
+    params.log?.debug?.(
+      `[DingTalk][Session] Failed to read session reasoning level from ${params.storePath}: ${getErrorMessage(err)}`,
+    );
+    return undefined;
+  }
+}
+
+function shouldDisableBlockStreamingForReplyMode(params: {
+  replyMode: ReplyMode;
+  reasoningLevel?: string;
+  sessionKey: string;
+  log?: Logger;
+}): boolean {
+  if (params.replyMode === "markdown") {
+    const shouldDisable = params.reasoningLevel === "on" || params.reasoningLevel === "stream";
+    if (shouldDisable) {
+      params.log?.debug?.(
+        `[DingTalk][Markdown] Disable block streaming for reasoningLevel=${params.reasoningLevel} sessionKey=${params.sessionKey}`,
+      );
+    }
+    return shouldDisable;
+  }
+
+  const shouldDisable = params.reasoningLevel !== "on";
+  if (!shouldDisable) {
+    params.log?.debug?.(
+      `[DingTalk][Card] Enable block streaming for reasoningLevel=${params.reasoningLevel} sessionKey=${params.sessionKey}`,
+    );
+  }
+  return shouldDisable;
+}
 
 function resolvePinnedMainDmOwner(params: {
   dmScope?: string;
@@ -234,6 +272,7 @@ function buildGroupTurnContextPrompt(params: {
 
 type ReplyStreamPayload = {
   text?: string;
+  isReasoning?: boolean;
 };
 
 type ReplyChunkInfo = {
@@ -360,7 +399,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   const rt = getDingTalkRuntime();
 
   // Save logger globally so shared services can log consistently without threading log everywhere.
-  setCurrentLogger(log);
+  setCurrentLogger(log, accountId);
 
   log?.debug?.("[DingTalk] Full Inbound Data: " + JSON.stringify(maskSensitiveData(data)));
 
@@ -623,430 +662,38 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   });
 
   const to = isDirect ? senderId : groupId;
-  const parsedLearnCommand = parseLearnCommand(extractedContent.text);
-  const parsedSessionCommand = parseSessionCommand(extractedContent.text);
-  const isOwner = isLearningOwner({
+  const commandHandled = await handleInboundCommandDispatch({
     cfg,
-    config: dingtalkConfig,
-    senderId,
-    rawSenderId: data.senderId,
-  });
-  if (isDirect && parsedLearnCommand.scope === "whoami") {
-    await sendBySession(
-      dingtalkConfig,
-      sessionWebhook,
-      formatWhoAmIReply({
-        senderId,
-        rawSenderId: data.senderId,
-        senderStaffId: data.senderStaffId,
-        isOwner,
-      }),
-      { log },
-    );
-    return;
-  }
-  if (parsedLearnCommand.scope === "whereami") {
-    await sendBySession(
-      dingtalkConfig,
-      sessionWebhook,
-      formatWhereAmIReply({
-        conversationId: data.conversationId,
-        conversationType: isDirect ? "dm" : "group",
-        peerId: sessionPeer.peerId,
-      }),
-      { log },
-    );
-    return;
-  }
-  if (isDirect && parsedLearnCommand.scope === "owner-status") {
-    await sendBySession(
-      dingtalkConfig,
-      sessionWebhook,
-      formatOwnerStatusReply({
-        senderId,
-        rawSenderId: data.senderId,
-        isOwner,
-      }),
-      { log },
-    );
-    return;
-  }
-  if (parsedLearnCommand.scope === "help") {
-    await sendBySession(dingtalkConfig, sessionWebhook, formatLearnCommandHelp(), { log });
-    return;
-  }
-  if (
-    (parsedLearnCommand.scope === "global" ||
-      parsedLearnCommand.scope === "session" ||
-      parsedLearnCommand.scope === "here" ||
-      parsedLearnCommand.scope === "target" ||
-      parsedLearnCommand.scope === "targets" ||
-      parsedLearnCommand.scope === "list" ||
-      parsedLearnCommand.scope === "disable" ||
-      parsedLearnCommand.scope === "delete" ||
-      parsedLearnCommand.scope === "target-set-create" ||
-      parsedLearnCommand.scope === "target-set-apply" ||
-      parsedSessionCommand.scope === "session-alias-show" ||
-      parsedSessionCommand.scope === "session-alias-set" ||
-      parsedSessionCommand.scope === "session-alias-clear" ||
-      parsedSessionCommand.scope === "session-alias-bind" ||
-      parsedSessionCommand.scope === "session-alias-unbind") &&
-    !isOwner
-  ) {
-    await sendBySession(dingtalkConfig, sessionWebhook, formatOwnerOnlyDeniedReply(), { log });
-    return;
-  }
-  if (isOwner) {
-    if (parsedSessionCommand.scope === "session-alias-show") {
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatSessionAliasReply({
-          sourceKind: currentSessionSourceKind,
-          sourceId: currentSessionSourceId,
-          peerId: sessionPeer.peerId,
-          aliasSource: peerIdOverride ? "override" : "default",
-        }),
-        { log },
-      );
-      return;
-    }
-    if (parsedSessionCommand.scope === "session-alias-set" && parsedSessionCommand.peerId) {
-      const aliasValidationError = validateSessionAlias(parsedSessionCommand.peerId);
-      if (aliasValidationError) {
-        await sendBySession(
-          dingtalkConfig,
-          sessionWebhook,
-          formatSessionAliasValidationErrorReply(aliasValidationError),
-          { log },
-        );
-        return;
-      }
-      setSessionPeerOverride({
-        storePath: accountStorePath,
-        accountId,
-        sourceKind: currentSessionSourceKind,
-        sourceId: currentSessionSourceId,
-        peerId: parsedSessionCommand.peerId,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatSessionAliasSetReply({
-          sourceKind: currentSessionSourceKind,
-          sourceId: currentSessionSourceId,
-          peerId: parsedSessionCommand.peerId,
-        }),
-        { log },
-      );
-      return;
-    }
-    if (parsedSessionCommand.scope === "session-alias-clear") {
-      clearSessionPeerOverride({
-        storePath: accountStorePath,
-        accountId,
-        sourceKind: currentSessionSourceKind,
-        sourceId: currentSessionSourceId,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatSessionAliasClearedReply({
-          sourceKind: currentSessionSourceKind,
-          sourceId: currentSessionSourceId,
-        }),
-        { log },
-      );
-      return;
-    }
-    if (
-      parsedSessionCommand.scope === "session-alias-bind" &&
-      parsedSessionCommand.sourceKind &&
-      parsedSessionCommand.sourceId &&
-      parsedSessionCommand.peerId
-    ) {
-      const aliasValidationError = validateSessionAlias(parsedSessionCommand.peerId);
-      if (aliasValidationError) {
-        await sendBySession(
-          dingtalkConfig,
-          sessionWebhook,
-          formatSessionAliasValidationErrorReply(aliasValidationError),
-          { log },
-        );
-        return;
-      }
-      setSessionPeerOverride({
-        storePath: accountStorePath,
-        accountId,
-        sourceKind: parsedSessionCommand.sourceKind,
-        sourceId: parsedSessionCommand.sourceId,
-        peerId: parsedSessionCommand.peerId,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatSessionAliasBoundReply({
-          sourceKind: parsedSessionCommand.sourceKind,
-          sourceId: parsedSessionCommand.sourceId,
-          peerId: parsedSessionCommand.peerId,
-        }),
-        { log },
-      );
-      return;
-    }
-    if (
-      parsedSessionCommand.scope === "session-alias-unbind" &&
-      parsedSessionCommand.sourceKind &&
-      parsedSessionCommand.sourceId
-    ) {
-      const existed = clearSessionPeerOverride({
-        storePath: accountStorePath,
-        accountId,
-        sourceKind: parsedSessionCommand.sourceKind,
-        sourceId: parsedSessionCommand.sourceId,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatSessionAliasUnboundReply({
-          sourceKind: parsedSessionCommand.sourceKind,
-          sourceId: parsedSessionCommand.sourceId,
-          existed,
-        }),
-        { log },
-      );
-      return;
-    }
-    if (parsedLearnCommand.scope === "global" && parsedLearnCommand.instruction) {
-      const applied = applyManualGlobalLearningRule({
-        storePath: accountStorePath,
-        accountId,
-        instruction: parsedLearnCommand.instruction,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatLearnAppliedReply({
-          scope: "global",
-          instruction: parsedLearnCommand.instruction,
-          ruleId: applied?.ruleId,
-        }),
-        { log },
-      );
-      return;
-    }
-    if (parsedLearnCommand.scope === "session" && parsedLearnCommand.instruction) {
-      applyManualSessionLearningNote({
-        storePath: accountStorePath,
-        accountId,
-        targetId: data.conversationId,
-        instruction: parsedLearnCommand.instruction,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatLearnAppliedReply({
-          scope: "session",
-          instruction: parsedLearnCommand.instruction,
-        }),
-        { log },
-      );
-      return;
-    }
-    if (parsedLearnCommand.scope === "here" && parsedLearnCommand.instruction) {
-      const applied = applyManualTargetLearningRule({
-        storePath: accountStorePath,
-        accountId,
-        targetId: data.conversationId,
-        instruction: parsedLearnCommand.instruction,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatLearnAppliedReply({
-          scope: "target",
-          targetId: data.conversationId,
-          instruction: parsedLearnCommand.instruction,
-          ruleId: applied?.ruleId,
-        }),
-        { log },
-      );
-      return;
-    }
-    if (
-      parsedLearnCommand.scope === "target" &&
-      parsedLearnCommand.targetId &&
-      parsedLearnCommand.instruction
-    ) {
-      const applied = applyManualTargetLearningRule({
-        storePath: accountStorePath,
-        accountId,
-        targetId: parsedLearnCommand.targetId,
-        instruction: parsedLearnCommand.instruction,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatLearnAppliedReply({
-          scope: "target",
-          targetId: parsedLearnCommand.targetId,
-          instruction: parsedLearnCommand.instruction,
-          ruleId: applied?.ruleId,
-        }),
-        { log },
-      );
-      return;
-    }
-    if (
-      parsedLearnCommand.scope === "targets" &&
-      parsedLearnCommand.targetIds?.length &&
-      parsedLearnCommand.instruction
-    ) {
-      const applied = applyManualTargetsLearningRule({
-        storePath: accountStorePath,
-        accountId,
-        targetIds: parsedLearnCommand.targetIds,
-        instruction: parsedLearnCommand.instruction,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatLearnAppliedReply({
-          scope: "targets",
-          targetIds: parsedLearnCommand.targetIds,
-          instruction: parsedLearnCommand.instruction,
-          ruleId: applied[0]?.ruleId,
-        }),
-        { log },
-      );
-      return;
-    }
-    if (
-      parsedLearnCommand.scope === "target-set-create" &&
-      parsedLearnCommand.setName &&
-      parsedLearnCommand.targetIds?.length
-    ) {
-      const saved = createOrUpdateTargetSet({
-        storePath: accountStorePath,
-        accountId,
-        name: parsedLearnCommand.setName,
-        targetIds: parsedLearnCommand.targetIds,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        saved
-          ? formatTargetSetSavedReply({
-              setName: parsedLearnCommand.setName,
-              targetIds: parsedLearnCommand.targetIds,
-            })
-          : "目标组保存失败，请检查名称和目标列表。",
-        { log },
-      );
-      return;
-    }
-    if (
-      parsedLearnCommand.scope === "target-set-apply" &&
-      parsedLearnCommand.setName &&
-      parsedLearnCommand.instruction
-    ) {
-      const applied = applyTargetSetLearningRule({
-        storePath: accountStorePath,
-        accountId,
-        name: parsedLearnCommand.setName,
-        instruction: parsedLearnCommand.instruction,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        applied.length > 0
-          ? formatLearnAppliedReply({
-              scope: "target-set",
-              setName: parsedLearnCommand.setName,
-              targetIds: applied.map((item) => item.targetId),
-              instruction: parsedLearnCommand.instruction,
-              ruleId: applied[0]?.ruleId,
-            })
-          : `未找到目标组 \`${parsedLearnCommand.setName}\`，或该目标组为空。`,
-        { log },
-      );
-      return;
-    }
-    if (parsedLearnCommand.scope === "list") {
-      const rules = listScopedLearningRules({ storePath: accountStorePath, accountId })
-        .slice(0, 20)
-        .map((rule) => {
-          const scope = rule.scope === "target" ? `target(${rule.targetId})` : "global";
-          const status = rule.enabled ? "enabled" : "disabled";
-          return `- [${scope}] ${rule.ruleId} (${status}) => ${rule.instruction}`;
-        });
-      const targetSets = listLearningTargetSets({ storePath: accountStorePath, accountId })
-        .slice(0, 10)
-        .map(
-          (targetSet) => `- [target-set] ${targetSet.name} => ${targetSet.targetIds.join(", ")}`,
-        );
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatLearnListReply([...rules, ...targetSets]),
-        { log },
-      );
-      return;
-    }
-    if (parsedLearnCommand.scope === "disable" && parsedLearnCommand.ruleId) {
-      const result = disableManualRule({
-        storePath: accountStorePath,
-        accountId,
-        ruleId: parsedLearnCommand.ruleId,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatLearnDisabledReply({
-          ruleId: parsedLearnCommand.ruleId,
-          existed: result.existed,
-          scope: result.scope,
-          targetId: result.targetId,
-        }),
-        { log },
-      );
-      return;
-    }
-    if (parsedLearnCommand.scope === "delete" && parsedLearnCommand.ruleId) {
-      const result = deleteManualRule({
-        storePath: accountStorePath,
-        accountId,
-        ruleId: parsedLearnCommand.ruleId,
-      });
-      await sendBySession(
-        dingtalkConfig,
-        sessionWebhook,
-        formatLearnDeletedReply({
-          ruleId: parsedLearnCommand.ruleId,
-          existed: result.existed,
-          scope: result.scope,
-          targetId: result.targetId,
-        }),
-        { log },
-      );
-      return;
-    }
-  }
-  const manualForcedReply = resolveManualForcedReply({
-    storePath: accountStorePath,
     accountId,
-    targetId: data.conversationId,
-    content: extractedContent,
+    dingtalkConfig,
+    senderId,
+    isDirect,
+    extractedText: extractedContent.text,
+    messageType: extractedContent.messageType,
+    data: {
+      conversationId: data.conversationId,
+      senderId: data.senderId,
+      senderStaffId: data.senderStaffId,
+    },
+    accountStorePath,
+    currentSessionSourceKind,
+    currentSessionSourceId,
+    peerIdOverride,
+    sessionPeer,
+    sendReply: async (text: string) => {
+      await sendBySession(dingtalkConfig, sessionWebhook, text, { log });
+    },
+    clearSessionPeerOverride,
+    setSessionPeerOverride,
   });
-  if (manualForcedReply) {
-    await sendBySession(dingtalkConfig, sessionWebhook, manualForcedReply, { log });
+  if (commandHandled) {
     return;
   }
   // 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.
   let useCardMode = dingtalkConfig.messageType === "card";
-  let currentAICard = undefined;
+  let currentAICard: import("./types").AICardInstance | undefined;
 
   if (useCardMode) {
     try {
@@ -1060,6 +707,15 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       });
       if (aiCard) {
         currentAICard = aiCard;
+        if (aiCard.outTrackId) {
+          registerCardRun(aiCard.outTrackId, {
+            accountId,
+            sessionKey: route.sessionKey,
+            agentId: route.agentId,
+            ownerUserId: senderId,
+            card: aiCard,
+          });
+        }
       } else {
         useCardMode = false;
         log?.warn?.(
@@ -1620,13 +1276,11 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   // tryFastAbortFromMessage (inside the SDK) kill any in-flight generation immediately,
   // rather than waiting for it to finish before the stop message is processed.
   //
-  // In group chats, DingTalk typically strips @BotName from text.content at the
-  // protocol level before delivery, but as a defensive measure we also strip leading
-  // @mention tokens here (e.g. "@Bot 停止" → "停止") to match the SDK's own behavior
-  // in tryFastAbortFromMessage (which calls stripMentions for group messages).
-  const textForAbortCheck = !isDirect
-    ? inboundText.replace(/^(?:@\S+\s+)*/u, "").trim()
-    : inboundText;
+  // Strip leading @mention tokens before the abort check so that messages like
+  // "@Agent /stop" are correctly recognised as abort requests in both DM and group
+  // chats. In groups DingTalk usually strips @BotName at the protocol level, but
+  // in DMs with multi-agent routing the @mention prefix survives all the way here.
+  const textForAbortCheck = inboundText.replace(/^(?:@\S+\s+)*/u, "").trim();
   if (isAbortRequestText(textForAbortCheck)) {
     log?.info?.(
       `[DingTalk] Abort request detected, bypassing session lock for session=${route.sessionKey}`,
@@ -1798,6 +1452,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   // causes empty replies for all but the first caller.
   // Each sub-agent call acquires its own lock since sub-agent sessions have
   // different session keys (different agentId), so no deadlock risk.
+  const currentOutTrackId = currentAICard?.outTrackId;
   const shouldTrackDynamicAckReaction =
     (normalizedAckReaction === "emoji" || normalizedAckReaction === "kaomoji")
     && shouldAttachAckReaction;
@@ -1826,22 +1481,51 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     if (!ackReactionAttached && shouldAttachAckReaction) {
       log?.debug?.("[DingTalk] Native ack reaction unavailable; skipping fallback.");
     }
+    const isCurrentCardStopRequested = () =>
+      Boolean(
+        currentAICard
+        && (
+          currentAICard.state === AICardStatus.STOPPED
+          || (currentOutTrackId && isCardRunStopRequested(currentOutTrackId))
+        ),
+      );
+
+    if (isCurrentCardStopRequested()) {
+      log?.info?.("[DingTalk][CardStop] Skip dispatch because card was already stopped before session lock was acquired");
+      return;
+    }
 
     // ---- Create reply strategy (card or markdown) ----
+    const replyMode: ReplyMode = useCardMode && !!currentAICard ? "card" : "markdown";
+    const sessionReasoningLevel = readSessionReasoningLevel({
+      storePath,
+      sessionKey: route.sessionKey,
+      sessionUpdatedAt: previousTimestamp,
+      log,
+    });
     const strategy = createReplyStrategy({
       config: dingtalkConfig,
       card: currentAICard,
-      useCardMode: useCardMode && !!currentAICard,
+      useCardMode: replyMode === "card",
       to,
       sessionWebhook,
       senderId,
       isDirect,
       accountId,
       storePath: accountStorePath,
+      sessionKey: route.sessionKey,
+      sessionAgentId: route.agentId,
+      disableBlockStreaming: shouldDisableBlockStreamingForReplyMode({
+        replyMode,
+        sessionKey: route.sessionKey,
+        reasoningLevel: sessionReasoningLevel,
+        log,
+      }),
       groupId,
       log,
       replyQuotedRef,
       deliverMedia: deliverMediaAttachments,
+      isStopRequested: isCurrentCardStopRequested,
     });
 
     try {
@@ -1851,12 +1535,18 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
         dispatcherOptions: {
           responsePrefix: subAgentOptions?.responsePrefix || "",
           deliver: async (payload: ReplyStreamPayload, info?: ReplyChunkInfo) => {
+            if (isCurrentCardStopRequested()) {
+              log?.debug?.("[DingTalk][CardStop] Ignoring reply delivery because stop was already requested");
+              return;
+            }
             try {
               const mediaUrls = extractMediaUrls(payload);
+              const richPayload = payload as ReplyStreamPayload & { isReasoning?: boolean };
               await strategy.deliver({
                 text: payload.text,
                 mediaUrls,
                 kind: (info?.kind as DeliverPayload["kind"]) || "block",
+                isReasoning: richPayload.isReasoning === true,
               });
             } catch (err: unknown) {
               log?.error?.(`[DingTalk] Reply failed: ${getErrorMessage(err)}`);
@@ -1878,6 +1568,13 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
 
     await strategy.finalize();
   } finally {
+    // Only remove the registry entry if no stop was requested. When a stop is
+    // in progress, card-stop-handler may still be running async operations
+    // (finalize card, hide button, gateway abort) that read the record.
+    // In that case, let the 30-minute TTL sweep handle cleanup.
+    if (currentOutTrackId && !isCardRunStopRequested(currentOutTrackId)) {
+      removeCardRun(currentOutTrackId);
+    }
     await waitForDynamicAckDispose({
       dispose: () => dynamicAckReactionController.dispose(MIN_THINKING_REACTION_VISIBLE_MS),
       log,