@soimy/dingtalk 3.6.6 → 3.6.7

package/src/inbound-handler.ts

@@ -13,6 +13,10 @@ import {
   isCardInTerminalState,
   recallAICardMessage,
 } from "./card-service";
+import {
+  invalidateAskUserQuestionsForScope,
+  syncInvalidatedAskUserQuestionCards,
+} from "./card/ask-user-question";
 import {
   getDingTalkQuestionContext,
   withDingTalkQuestionContext,
@@ -81,7 +85,13 @@ import {
   upsertObservedUserTarget,
 } from "./targeting/target-directory-store";
 import { AICardStatus } from "./types";
-import type { DingTalkConfig, HandleDingTalkMessageParams, Logger, MediaFile } from "./types";
+import type {
+  DingTalkConfig,
+  HandleDingTalkMessageParams,
+  Logger,
+  MediaFile,
+  ResolvedDingTalkRoute,
+} from "./types";
 import {
   formatDingTalkErrorPayloadLog,
   getErrorMessage,
@@ -584,6 +594,8 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
     sessionWebhook,
     log,
     dingtalkConfig,
+    inboundOrigin = "stream",
+    routeOverride,
     subAgentOptions,
     preDownloadedMedia,
   } = params;
@@ -810,38 +822,42 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
     ? 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,
-        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 invalidateQuestionRoutes = (routes: readonly ResolvedDingTalkRoute[]): void => {
+    if (inboundOrigin === "ask-user") {
+      return;
+    }
+    const scopeKeys = new Set(
+      routes.map((resolvedRoute) => `${accountId}:${resolvedRoute.sessionKey}:${senderId}`),
+    );
+    const invalidatedRecords = [];
+    for (const questionScopeKey of scopeKeys) {
+      try {
+        invalidatedRecords.push(
+          ...invalidateAskUserQuestionsForScope({
+            storePath: accountStorePath,
+            accountId,
+            questionScopeKey,
+            reason: "superseded_by_message",
+            log,
+          }),
+        );
+      } catch (err) {
+        log?.warn?.(
+          `[DingTalk][AskUser] Failed to invalidate pending cards before inbound dispatch scope=${questionScopeKey}: ${String(err)}`,
+        );
+      }
+    }
+    if (invalidatedRecords.length === 0) {
+      return;
+    }
+    void syncInvalidatedAskUserQuestionCards({
+      records: invalidatedRecords,
+      config: dingtalkConfig,
+      log,
+    }).catch((err) => {
+      log?.warn?.(`[DingTalk][AskUser] Card invalidation sync failed: ${String(err)}`);
     });
-  }
-  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
@@ -858,6 +874,9 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         dingtalkConfig,
         sessionWebhook,
         extractedContent,
+        sessionPeer,
+        onRoutesResolved: (targets) =>
+          invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
         log,
@@ -889,6 +908,9 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         dingtalkConfig,
         sessionWebhook,
         extractedContent,
+        sessionPeer,
+        onRoutesResolved: (targets) =>
+          invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
         log,
@@ -898,6 +920,47 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
     // Only invalid agent names and no match: fall through to the default route.
   }
 
+  let route: ResolvedDingTalkRoute;
+  if (routeOverride) {
+    route = routeOverride;
+  } else if (subAgentOptions) {
+    route = {
+      agentId: subAgentOptions.agentId,
+      sessionKey: buildAgentSessionKey({
+        rt,
+        cfg,
+        accountId,
+        agentId: subAgentOptions.agentId,
+        peerKind: sessionPeer.kind,
+        peerId: sessionPeer.peerId,
+      }),
+      mainSessionKey: "",
+    };
+  } else {
+    route = rt.channel.routing.resolveAgentRoute({
+      cfg,
+      channel: "dingtalk",
+      accountId,
+      peer: { kind: sessionPeer.kind, id: sessionPeer.peerId },
+    });
+  }
+  const questionContext = getDingTalkQuestionContext();
+  if (questionContext) {
+    questionContext.resolvedRoute = route;
+    questionContext.questionScopeKey = `${accountId}:${route.sessionKey}:${senderId}`;
+    questionContext.storePath = accountStorePath;
+    questionContext.continuationSubAgentOptions = subAgentOptions
+      ? {
+          agentId: subAgentOptions.agentId,
+          responsePrefix: subAgentOptions.responsePrefix,
+          matchedName: subAgentOptions.matchedName,
+        }
+      : undefined;
+  }
+  if (!subAgentOptions) {
+    invalidateQuestionRoutes([route]);
+  }
+
   // Route resolved before media download for session context and routing metadata.
   const storePath = rt.channel.session.resolveStorePath(cfg.session?.store, {
     agentId: route.agentId,
@@ -978,7 +1041,6 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
   let cardFlightKey: string | undefined;
   if (questionContext) {
     questionContext.onQuestionCardSent = async ({ questionId, outTrackId }) => {
-      questionCardTookOver = true;
       if (cardFlightKey) {
         cardCreationInFlight.delete(cardFlightKey);
         cardFlightKey = undefined;
@@ -999,23 +1061,34 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         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)}`,
         );
+        return false;
       }
+      questionCardTookOver = true;
       if (!currentAICard) {
-        return;
+        return true;
       }
       if (isCardInTerminalState(currentAICard.state)) {
-        return;
+        return true;
+      }
+      let recalled = false;
+      try {
+        recalled = await recallAICardMessage(currentAICard, log);
+      } catch (err) {
+        log?.warn?.(
+          `[DingTalk][AskUser] Question card took over, but AI card recall errored question=${questionId} outTrackId=${outTrackId}: ${err instanceof Error ? err.message : String(err)}`,
+        );
+        return true;
       }
-      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;
+        return true;
       }
       log?.info?.(
         `[DingTalk][AskUser] Recalled empty AI card after question card sent question=${questionId} outTrackId=${outTrackId}`,
       );
+      return true;
     };
   }
 

package/src/targeting/agent-routing.ts

@@ -20,9 +20,11 @@ import type {
   HandleDingTalkMessageParams,
   Logger,
   MessageContent,
+  ResolvedDingTalkRoute,
 } from "../types";
 import { getErrorMessage } from "../utils";
 import { resolveAtAgents } from "./agent-name-matcher";
+import type { ResolvedDingTalkSessionPeer } from "../session-routing";
 
 export class HostRoutingHelperUnavailableError extends Error {
   constructor(
@@ -84,6 +86,11 @@ export type MessageTarget =
     }
   | { kind: "subagent-command"; agent: AgentNameMatch; commandText: string };
 
+export interface ResolvedSubAgentTarget {
+  agent: AgentNameMatch;
+  route: ResolvedDingTalkRoute;
+}
+
 /**
  * Resolve how an inbound message should be routed.
  *
@@ -198,6 +205,8 @@ export async function dispatchSubAgents(params: {
   dingtalkConfig: DingTalkConfig;
   sessionWebhook: string;
   extractedContent: MessageContent;
+  sessionPeer: ResolvedDingTalkSessionPeer;
+  onRoutesResolved?: (targets: readonly ResolvedSubAgentTarget[]) => void;
   handleMessage: (params: HandleDingTalkMessageParams) => Promise<void>;
   downloadMedia: (
     config: DingTalkConfig,
@@ -215,11 +224,64 @@ export async function dispatchSubAgents(params: {
     dingtalkConfig,
     sessionWebhook,
     extractedContent,
+    sessionPeer,
+    onRoutesResolved,
     handleMessage,
     downloadMedia: download,
     log,
   } = params;
 
+  let helperMissingWarningSent = false;
+  const sendHelperMissingWarning = async (): Promise<void> => {
+    if (helperMissingWarningSent) {
+      return;
+    }
+    helperMissingWarningSent = true;
+    try {
+      const isGroup = data.conversationType !== "1";
+      const sendOptions = isGroup ? { atUserId: data.senderId, log } : { log };
+      await sendBySession(
+        dingtalkConfig,
+        sessionWebhook,
+        "⚠️ 当前宿主版本不支持 DingTalk 子助手路由所需的 session helper，请升级 OpenClaw 后重试。",
+        sendOptions,
+      );
+    } catch (notifyError: unknown) {
+      log?.debug?.(
+        `[DingTalk] Failed to send sub-agent helper-missing notice: ${getErrorMessage(notifyError)}`,
+      );
+    }
+  };
+
+  let resolvedTargets: ResolvedSubAgentTarget[];
+  try {
+    const rt = getDingTalkRuntime();
+    resolvedTargets = matchedAgents.map((agent) => ({
+      agent,
+      route: {
+        agentId: agent.agentId,
+        sessionKey: buildAgentSessionKey({
+          rt,
+          cfg,
+          accountId,
+          agentId: agent.agentId,
+          peerKind: sessionPeer.kind,
+          peerId: sessionPeer.peerId,
+        }),
+        mainSessionKey: "",
+      },
+    }));
+  } catch (error) {
+    const message = getErrorMessage(error);
+    log?.error?.(`[DingTalk] Failed to resolve sub-agent routes: ${message}`);
+    if (error instanceof HostRoutingHelperUnavailableError) {
+      await sendHelperMissingWarning();
+      return;
+    }
+    throw error;
+  }
+  onRoutesResolved?.(resolvedTargets);
+
   // Pre-download media once to avoid duplication across sub-agents
   let preDownloadedMedia:
     | {
@@ -255,9 +317,8 @@ export async function dispatchSubAgents(params: {
       };
     }
   }
-  let helperMissingWarningSent = false;
-
-  for (const agentMatch of matchedAgents) {
+  for (const target of resolvedTargets) {
+    const agentMatch = target.agent;
     try {
       await handleMessage({
         cfg,
@@ -266,6 +327,7 @@ export async function dispatchSubAgents(params: {
         sessionWebhook,
         log,
         dingtalkConfig,
+        routeOverride: target.route,
         subAgentOptions: {
           agentId: agentMatch.agentId,
           responsePrefix: commandText
@@ -279,22 +341,8 @@ export async function dispatchSubAgents(params: {
     } catch (error) {
       const message = getErrorMessage(error);
       log?.error?.(`[DingTalk] Sub-agent ${agentMatch.agentId} failed: ${message}`);
-      if (error instanceof HostRoutingHelperUnavailableError && !helperMissingWarningSent) {
-        helperMissingWarningSent = true;
-        try {
-          const isGroup = data.conversationType !== "1";
-          const sendOptions = isGroup ? { atUserId: data.senderId, log } : { log };
-          await sendBySession(
-            dingtalkConfig,
-            sessionWebhook,
-            "⚠️ 当前宿主版本不支持 DingTalk 子助手路由所需的 session helper，请升级 OpenClaw 后重试。",
-            sendOptions,
-          );
-        } catch (notifyError: unknown) {
-          log?.debug?.(
-            `[DingTalk] Failed to send sub-agent helper-missing notice: ${getErrorMessage(notifyError)}`,
-          );
-        }
+      if (error instanceof HostRoutingHelperUnavailableError) {
+        await sendHelperMissingWarning();
       }
     }
   }

package/src/types.ts

@@ -462,6 +462,16 @@ export interface SubAgentOptions {
   commandText?: string;
 }
 
+/**
+ * A trusted route resolved by the plugin before recursive or synthetic inbound handling.
+ * It is runtime-only and must never be populated from DingTalk callback payload fields.
+ */
+export interface ResolvedDingTalkRoute {
+  agentId: string;
+  sessionKey: string;
+  mainSessionKey: string;
+}
+
 /**
  * Message handler parameters
  */
@@ -472,6 +482,10 @@ export interface HandleDingTalkMessageParams {
   sessionWebhook: string;
   log?: Logger;
   dingtalkConfig: DingTalkConfig;
+  /** Distinguishes real Stream messages from Ask User callback reinjection. */
+  inboundOrigin?: "stream" | "ask-user";
+  /** Reuses an already-resolved trusted route for recursive or synthetic handling. */
+  routeOverride?: ResolvedDingTalkRoute;
   /**
    * When set, routes message to the specified sub-agent instead of main agent.
    * This enables reuse of the main message handling logic for sub-agents.