@soimy/dingtalk 3.6.3 → 3.6.5

package/src/card/card-action-handler.ts

@@ -1,6 +1,7 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { CardCallbackAnalysis } from "../card-callback-service";
 import type { DingTalkConfig, Logger } from "../types";
+import { handleDingTalkAskUserCardCallback } from "./ask-user-question";
 import { resolveCardRun } from "./card-run-registry";
 import { stopCardRun } from "./card-stop-handler";
 
@@ -9,12 +10,25 @@ export interface CardActionResult {
 }
 
 export async function handleCardAction(params: {
+  payload: unknown;
   analysis: CardCallbackAnalysis;
   cfg: OpenClawConfig;
   accountId: string;
   config: DingTalkConfig;
   log?: Logger;
 }): Promise<CardActionResult> {
+  const askUserResult = await handleDingTalkAskUserCardCallback({
+    payload: params.payload,
+    cfg: params.cfg,
+    accountId: params.accountId,
+    config: params.config,
+    clickerUserId: params.analysis.userId,
+    log: params.log,
+  });
+  if (askUserResult.handled) {
+    return askUserResult;
+  }
+
   if (params.analysis.actionId !== "btn_stop") {
     return { handled: false };
   }

package/src/card/card-template.ts

@@ -8,6 +8,8 @@ export const BUILTIN_DINGTALK_CARD_TEMPLATE_ID =
 export const BUILTIN_DINGTALK_CARD_CONTENT_KEY = "content";
 export const BUILTIN_DINGTALK_CARD_BLOCK_LIST_KEY = "blockList";
 export const BUILTIN_DINGTALK_CARD_COPY_CONTENT_KEY = "copy_content";
+export const BUILTIN_DINGTALK_ASK_USER_CARD_TEMPLATE_ID =
+  "89d0c6fe-3822-44c8-950e-e950f562546d.schema";
 
 export interface DingTalkCardTemplateContract {
   templateId: string;
@@ -20,6 +22,10 @@ export interface DingTalkCardTemplateContract {
   copyContentKey: string;
 }
 
+export interface DingTalkAskUserCardTemplateContract {
+  templateId: string;
+}
+
 /** Frozen singleton — no allocation on every call. */
 export const DINGTALK_CARD_TEMPLATE: Readonly<DingTalkCardTemplateContract> = Object.freeze({
   templateId: BUILTIN_DINGTALK_CARD_TEMPLATE_ID,
@@ -29,3 +35,7 @@ export const DINGTALK_CARD_TEMPLATE: Readonly<DingTalkCardTemplateContract> = Ob
   copyContentKey: BUILTIN_DINGTALK_CARD_COPY_CONTENT_KEY,
 });
 
+export const DINGTALK_ASK_USER_CARD_TEMPLATE: Readonly<DingTalkAskUserCardTemplateContract> =
+  Object.freeze({
+    templateId: BUILTIN_DINGTALK_ASK_USER_CARD_TEMPLATE_ID,
+  });

package/src/gateway/channel-gateway.ts

@@ -1,10 +1,7 @@
 import { DWClient, TOPIC_CARD, TOPIC_ROBOT } from "dingtalk-stream";
 import { analyzeCardCallback } from "../card-callback-service";
+import { finalizeActiveCardsForAccount, recoverPendingCardsForAccount } from "../card-service";
 import { handleCardAction } from "../card/card-action-handler";
-import {
-  finalizeActiveCardsForAccount,
-  recoverPendingCardsForAccount,
-} from "../card-service";
 import { resolveRobotCode, resolveRuntimeConfig } from "../config";
 import { ConnectionManager } from "../connection-manager";
 import { isMessageProcessed, markMessageProcessed } from "../dedup";
@@ -381,6 +378,7 @@ export function createDingTalkGateway(): NonNullable<DingTalkChannelPlugin["gate
               }
             }
             const actionResult = await handleCardAction({
+              payload,
               analysis,
               cfg,
               accountId: account.accountId,
@@ -500,7 +498,9 @@ export function createDingTalkGateway(): NonNullable<DingTalkChannelPlugin["gate
               lastStartAt: getCurrentTimestamp(),
               lastError: null,
             });
-            pluginLog?.info?.(`[${account.accountId}] DingTalk Stream client connected successfully`);
+            pluginLog?.info?.(
+              `[${account.accountId}] DingTalk Stream client connected successfully`,
+            );
             await nativeStopPromise;
           }
         } catch (err: any) {

package/src/inbound-handler.ts

@@ -7,9 +7,19 @@ import { classifyAckReactionEmoji } from "./ack-reaction-classifier";
 import { attachNativeAckReaction } from "./ack-reaction-service";
 import { createDynamicAckReactionController } from "./ack-reaction/dynamic-ack-reaction-controller";
 import { getAccessToken } from "./auth";
-import { createAICard, commitAICardBlocks, isCardInTerminalState } from "./card-service";
+import {
+  createAICard,
+  commitAICardBlocks,
+  isCardInTerminalState,
+  recallAICardMessage,
+} from "./card-service";
+import {
+  getDingTalkQuestionContext,
+  withDingTalkQuestionContext,
+} from "./card/ask-user-question-context";
 import { isCardRunStopRequested, registerCardRun, removeCardRun } from "./card/card-run-registry";
 import { renderStatusLine } from "./card/statusline-renderer";
+import { dispatchDingTalkCardStopCommand } from "./command/card-stop-command";
 import { handleInboundCommandDispatch } from "./command/inbound-command-dispatch-service";
 import {
   resolveAckReactionSetting,
@@ -60,8 +70,9 @@ import { getSessionState, initSessionState } from "./session-state";
 import { getAgentDisplayName } from "./targeting/agent-name-matcher";
 import {
   buildAgentSessionKey,
-  resolveSubAgentRoute,
   dispatchSubAgents,
+  resolveMessageTarget,
+  sendUnmatchedAgentNotice,
 } from "./targeting/agent-routing";
 import { formatGroupMembers, noteGroupMember } from "./targeting/group-members-store";
 import {
@@ -547,6 +558,23 @@ export async function downloadMedia(
 }
 
 export async function handleDingTalkMessage(params: HandleDingTalkMessageParams): Promise<void> {
+  // Keep context creation inside this public inbound entry. Ask-user synthetic
+  // reinjections call handleDingTalkMessage directly, so moving this wrapper to
+  // gateway callbacks would lose per-message isolation for reinjected answers.
+  return withDingTalkQuestionContext(
+    {
+      cfg: params.cfg,
+      accountId: params.accountId,
+      data: params.data,
+      sessionWebhook: params.sessionWebhook,
+      log: params.log,
+      dingtalkConfig: params.dingtalkConfig,
+    },
+    () => handleDingTalkMessageInner(params),
+  );
+}
+
+async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams): Promise<void> {
   const {
     cfg,
     accountId,
@@ -580,8 +608,10 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   // for use in card quoteContent which should show the user's original message.
   const rawInboundText = extractedContent.text.trim();
 
-  // Add context hint for sub-agent mode, stripping quoted prefix to avoid protocol noise in agent context.
-  if (subAgentOptions) {
+  // Add context hint for sub-agent content mode, stripping quoted prefix to avoid protocol noise
+  // in agent context. Skipped for targeted slash commands (`commandText` set): the hint would
+  // pollute RawBody, and the command never reaches the agent's LLM anyway.
+  if (subAgentOptions && !subAgentOptions.commandText) {
     const cleanText = extractedContent.text.replace(/^\[引用[^\]]*\]\s*/, "");
     const contextHint = `[你被 @ 为"${subAgentOptions.matchedName}"]\n\n`;
     extractedContent.text = contextHint + cleanText;
@@ -772,40 +802,85 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     config: dingtalkConfig,
   });
 
-  const route = subAgentOptions
-    ? {
+  // Single routing decision for this message. Skipped for recursive sub-agent
+  // calls, where routing is already fixed by subAgentOptions.
+  const messageTarget = subAgentOptions
+    ? null
+    : resolveMessageTarget({ extractedContent, cfg, isGroup });
+
+  let route: { agentId: string; sessionKey: string; mainSessionKey: string };
+  if (subAgentOptions) {
+    // Recursive sub-agent dispatch (content or targeted command): route to the
+    // agent's own session. A missing host helper throws here and is caught by
+    // dispatchSubAgents in the parent call.
+    route = {
+      agentId: subAgentOptions.agentId,
+      sessionKey: buildAgentSessionKey({
+        rt,
+        cfg,
+        accountId,
         agentId: subAgentOptions.agentId,
-        sessionKey: buildAgentSessionKey({
-          rt,
-          cfg,
-          accountId,
-          agentId: subAgentOptions.agentId,
-          peerKind: sessionPeer.kind,
-          peerId: sessionPeer.peerId,
-        }),
-        mainSessionKey: "",
-      }
-    : rt.channel.routing.resolveAgentRoute({
+        peerKind: sessionPeer.kind,
+        peerId: sessionPeer.peerId,
+      }),
+      mainSessionKey: "",
+    };
+  } else {
+    // Default route. For subagent-content / subagent-command targets the
+    // dispatch below re-enters this function with subAgentOptions set, so this
+    // route is only consumed when the target is "default".
+    route = rt.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: "dingtalk",
+      accountId,
+      peer: { kind: sessionPeer.kind, id: sessionPeer.peerId },
+    });
+  }
+  const questionContext = getDingTalkQuestionContext();
+  if (questionContext) {
+    questionContext.questionScopeKey = `${accountId}:${route.sessionKey}:${senderId}`;
+  }
+
+  // @Sub-Agent routing: dispatch @mention-targeted messages to their agent(s).
+  // Both content (`@agent <message>`) and commands (`@agent /new`) re-enter
+  // handleDingTalkMessage via dispatchSubAgents with subAgentOptions set, so the
+  // agent session key, helper-missing fallback, and recursion live in one path.
+  if (messageTarget && messageTarget.kind !== "default") {
+    if (messageTarget.kind === "subagent-command") {
+      await dispatchSubAgents({
+        matchedAgents: [messageTarget.agent],
+        commandText: messageTarget.commandText,
         cfg,
-        channel: "dingtalk",
         accountId,
-        peer: { kind: sessionPeer.kind, id: sessionPeer.peerId },
+        data,
+        dingtalkConfig,
+        sessionWebhook,
+        extractedContent,
+        handleMessage: handleDingTalkMessage,
+        downloadMedia,
+        log,
       });
+      return;
+    }
 
-  // @Sub-Agent routing: resolve @mentions to agents (skip in recursive sub-agent calls)
-  if (!subAgentOptions) {
-    const subAgentRoute = await resolveSubAgentRoute({
-      extractedContent,
-      cfg,
-      isGroup,
-      dingtalkConfig,
-      sessionWebhook,
-      senderId,
-      log,
-    });
-    if (subAgentRoute) {
+    if (messageTarget.hasInvalidAgentNames) {
+      await sendUnmatchedAgentNotice({
+        unmatchedNames: messageTarget.unmatchedNames,
+        isGroup,
+        senderId,
+        dingtalkConfig,
+        sessionWebhook,
+        log,
+      });
+    }
+    if (messageTarget.matchedAgents.length > 0) {
+      log?.info?.(
+        `[DingTalk] Sub-agent resolve: matched=${messageTarget.matchedAgents
+          .map((a) => a.agentId)
+          .join(",")} unmatched=${messageTarget.unmatchedNames.join(",")}`,
+      );
       await dispatchSubAgents({
-        ...subAgentRoute,
+        matchedAgents: messageTarget.matchedAgents,
         cfg,
         accountId,
         data,
@@ -818,6 +893,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       });
       return;
     }
+    // Only invalid agent names and no match: fall through to the default route.
   }
 
   // Route resolved before media download for session context and routing metadata.
@@ -832,7 +908,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     dingtalkConfig,
     senderId,
     isDirect,
-    extractedText: extractedContent.text,
+    extractedText: subAgentOptions?.commandText ?? extractedContent.text,
     messageType: extractedContent.messageType,
     data: {
       conversationId: data.conversationId,
@@ -885,8 +961,52 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   // sending a separate plain-text message.
   let useCardMode = dingtalkConfig.messageType === "card";
   let currentAICard: import("./types").AICardInstance | undefined;
+  let questionCardTookOver = false;
 
   let cardFlightKey: string | undefined;
+  if (questionContext) {
+    questionContext.onQuestionCardSent = async ({ questionId, outTrackId }) => {
+      questionCardTookOver = true;
+      if (cardFlightKey) {
+        cardCreationInFlight.delete(cardFlightKey);
+        cardFlightKey = undefined;
+      }
+      try {
+        await dispatchDingTalkCardStopCommand({
+          cfg,
+          accountId,
+          agentId: route.agentId,
+          targetSessionKey: route.sessionKey,
+          clickerUserId: senderId || "unknown",
+          log,
+        });
+        log?.info?.(
+          `[DingTalk][AskUser] Dispatched targeted stop after question card sent question=${questionId} outTrackId=${outTrackId} targetSessionKey=${route.sessionKey}`,
+        );
+      } catch (err) {
+        log?.warn?.(
+          `[DingTalk][AskUser] Question card sent, but targeted stop failed question=${questionId} outTrackId=${outTrackId} targetSessionKey=${route.sessionKey}: ${err instanceof Error ? err.message : String(err)}`,
+        );
+      }
+      if (!currentAICard) {
+        return;
+      }
+      if (isCardInTerminalState(currentAICard.state)) {
+        return;
+      }
+      const recalled = await recallAICardMessage(currentAICard, log);
+      if (!recalled) {
+        log?.warn?.(
+          `[DingTalk][AskUser] Question card sent, but AI card recall failed; normal replies remain suppressed question=${questionId} outTrackId=${outTrackId}`,
+        );
+        return;
+      }
+      log?.info?.(
+        `[DingTalk][AskUser] Recalled empty AI card after question card sent question=${questionId} outTrackId=${outTrackId}`,
+      );
+    };
+  }
+
   if (useCardMode && !isBtwBypass) {
     const key = `${accountId}:${to}`;
     if (cardCreationInFlight.has(key)) {
@@ -1497,6 +1617,10 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     const inboundText = attachmentExtractedText
       ? `${inboundBody.trimEnd()}\n\n${attachmentExtractedText}`
       : inboundBody;
+    // Targeted slash commands (`@agent /new`) pass the @mention-stripped command
+    // text as CommandBody so the framework command layer recognizes it, while
+    // RawBody keeps the user's original input for audit/quote display.
+    const commandBody = subAgentOptions?.commandText ?? inboundText;
     const learningEnabled = isLearningEnabled(dingtalkConfig);
     const learningContextBlock = buildLearningContextBlock({
       enabled: learningEnabled,
@@ -1546,7 +1670,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     const ctx = rt.channel.reply.finalizeInboundContext({
       Body: body,
       RawBody: inboundText,
-      CommandBody: inboundText,
+      CommandBody: commandBody,
       QuotedRef: quotedRef,
       QuotedRefJson: quotedRef ? JSON.stringify(quotedRef) : undefined,
       ReplyToId: quotedRuntimeContext?.replyToId,
@@ -2114,11 +2238,18 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
                 const inlineReplyPayload = parseInlineReplyPayloadText(payload.text);
                 const mediaUrls = extractMediaUrls(payload, inlineReplyPayload);
                 const richPayload = payload as ReplyStreamPayload & { isReasoning?: boolean };
+                const replyKind = (info?.kind as DeliverPayload["kind"]) || "block";
+                if (questionCardTookOver) {
+                  log?.info?.(
+                    `[DingTalk][AskUser] Suppressed ${replyKind} reply after question card took over`,
+                  );
+                  return;
+                }
                 await strategy.deliver({
                   text: inlineReplyPayload.text,
                   mediaUrls,
                   audioAsVoice: extractSharedAudioAsVoice(payload, inlineReplyPayload),
-                  kind: (info?.kind as DeliverPayload["kind"]) || "block",
+                  kind: replyKind,
                   isReasoning: richPayload.isReasoning === true,
                 });
               } catch (err: unknown) {
@@ -2163,13 +2294,19 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
             typeof bufferedFinalPayload.text === "string" &&
             bufferedFinalPayload.text.trim().length > 0;
           if (hasBufferedText || mediaUrls.length > 0) {
-            await strategy.deliver({
-              text: inlineReplyPayload.text,
-              mediaUrls,
-              audioAsVoice: extractSharedAudioAsVoice(bufferedFinalPayload, inlineReplyPayload),
-              kind: "final",
-              isReasoning: bufferedFinalPayload.isReasoning === true,
-            });
+            if (questionCardTookOver) {
+              log?.info?.(
+                "[DingTalk][AskUser] Suppressed buffered final after question card took over",
+              );
+            } else {
+              await strategy.deliver({
+                text: inlineReplyPayload.text,
+                mediaUrls,
+                audioAsVoice: extractSharedAudioAsVoice(bufferedFinalPayload, inlineReplyPayload),
+                kind: "final",
+                isReasoning: bufferedFinalPayload.isReasoning === true,
+              });
+            }
           }
         }
       } catch (dispatchErr: unknown) {
@@ -2179,6 +2316,12 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
         throw dispatchErr;
       }
 
+      if (questionCardTookOver) {
+        log?.info?.(
+          "[DingTalk][AskUser] Skipping normal AI card finalize after question card took over",
+        );
+        return;
+      }
       await strategy.finalize();
     } finally {
       // Only remove the registry entry if no stop was requested. When a stop is

package/src/reply-strategy-card.ts

@@ -133,6 +133,8 @@ export function createCardReplyStrategy(
   let latestReasoningSnapshot = "";
   /** Non-image media attachments deferred for out-of-card delivery. */
   let pendingNonImageMedia: DeferredMedia[] = [];
+  /** URLs already processed in this card session — prevents duplicate upload/send when the same mediaUrl appears in both a non-final and final deliver. */
+  const processedMediaUrls = new Set<string>();
 
   const getRenderedTimeline = (options: { preferFinalAnswer?: boolean } = {}): string => {
     const fallbackAnswer = finalTextForFallback || (sawFinalDelivery ? EMPTY_FINAL_REPLY : undefined);
@@ -345,6 +347,12 @@ export function createCardReplyStrategy(
         continue;
       }
 
+      if (processedMediaUrls.has(candidate.url.trim())) {
+        const placeholder = buildImagePlaceholderText({ alt: candidate.alt, url: candidate.url });
+        nextText = `${nextText.slice(0, candidate.start)}${placeholder}${nextText.slice(candidate.end)}`;
+        continue;
+      }
+
       let prepared: Awaited<ReturnType<typeof prepareMediaInput>> | undefined;
       try {
         prepared = await prepareMediaInput(candidate.url, log, config.mediaUrlAllowlist);
@@ -361,6 +369,7 @@ export function createCardReplyStrategy(
           continue;
         }
 
+        processedMediaUrls.add(candidate.url.trim());
         const placeholder = buildImagePlaceholderText({ alt: candidate.alt, url: candidate.url });
         const blockText = candidate.alt.trim() || placeholder.replace(/^见下图/, "").trim() || "图片";
         successfulReroutes.push({
@@ -477,6 +486,10 @@ export function createCardReplyStrategy(
         // Inline media upload → image blocks in card; defer non-image attachments
         if (payload.mediaUrls.length > 0) {
           for (const url of payload.mediaUrls) {
+            const normalizedUrl = url.trim();
+            if (processedMediaUrls.has(normalizedUrl)) {
+              continue;
+            }
             try {
               const prepared = await prepareMediaInput(url, log, config.mediaUrlAllowlist);
               const mediaType = resolveOutboundMediaType({ mediaPath: prepared.path, asVoice: false });
@@ -492,6 +505,7 @@ export function createCardReplyStrategy(
               const result = await uploadMedia(config, prepared.path, "image", log);
               await prepared.cleanup?.();
               if (result?.mediaId) {
+                processedMediaUrls.add(normalizedUrl);
                 await controller.appendImageBlock(result.mediaId);
               }
             } catch (err: unknown) {
@@ -555,6 +569,10 @@ export function createCardReplyStrategy(
       // ---- block: only handle reasoning/media (other text blocks are unused) ----
       if (payload.mediaUrls.length > 0) {
         for (const url of payload.mediaUrls) {
+          const normalizedUrl = url.trim();
+          if (processedMediaUrls.has(normalizedUrl)) {
+            continue;
+          }
           try {
             const prepared = await prepareMediaInput(url, log, config.mediaUrlAllowlist);
             const mediaType = resolveOutboundMediaType({ mediaPath: prepared.path, asVoice: false });
@@ -567,6 +585,7 @@ export function createCardReplyStrategy(
             const result = await uploadMedia(config, prepared.path, "image", log);
             await prepared.cleanup?.();
             if (result?.mediaId) {
+              processedMediaUrls.add(normalizedUrl);
               await controller.appendImageBlock(result.mediaId);
             }
           } catch (err: unknown) {