@soimy/dingtalk 3.6.5 → 3.6.7

package/src/inbound-handler.ts

@@ -13,12 +13,17 @@ import {
   isCardInTerminalState,
   recallAICardMessage,
 } from "./card-service";
+import {
+  invalidateAskUserQuestionsForScope,
+  syncInvalidatedAskUserQuestionCards,
+} from "./card/ask-user-question";
 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 { resolveConfiguredTaskModelMetadata } from "./card/task-model-metadata";
 import { dispatchDingTalkCardStopCommand } from "./command/card-stop-command";
 import { handleInboundCommandDispatch } from "./command/inbound-command-dispatch-service";
 import {
@@ -80,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,
@@ -428,6 +439,7 @@ function buildGroupTurnContextPrompt(params: {
 
 type ReplyStreamPayload = {
   text?: string;
+  isError?: boolean;
   isReasoning?: boolean;
   mediaUrl?: string;
   mediaUrls?: string[];
@@ -582,6 +594,8 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
     sessionWebhook,
     log,
     dingtalkConfig,
+    inboundOrigin = "stream",
+    routeOverride,
     subAgentOptions,
     preDownloadedMedia,
   } = params;
@@ -808,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
@@ -856,6 +874,9 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         dingtalkConfig,
         sessionWebhook,
         extractedContent,
+        sessionPeer,
+        onRoutesResolved: (targets) =>
+          invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
         log,
@@ -887,6 +908,9 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         dingtalkConfig,
         sessionWebhook,
         extractedContent,
+        sessionPeer,
+        onRoutesResolved: (targets) =>
+          invalidateQuestionRoutes(targets.map((target) => target.route)),
         handleMessage: handleDingTalkMessage,
         downloadMedia,
         log,
@@ -896,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,
@@ -936,17 +1001,27 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
   const content = extractedContent;
   const isBtwBypass = isBtwRequestText(stripLeadingMentions(content.text).trim());
   const taskInfoConversationId = groupId || to;
-  const sessionTaskState = initSessionState(accountId, taskInfoConversationId);
+  const agentDisplayName = getAgentDisplayName({
+    subAgentOptions,
+    agentId: route.agentId,
+    agentsList: cfg.agents?.list,
+  });
+  const configuredTaskMetadata = resolveConfiguredTaskModelMetadata({
+    cfg,
+    agentId: route.agentId,
+  });
+  const sessionTaskStateScope = {
+    accountId,
+    conversationId: taskInfoConversationId,
+    agentId: route.agentId,
+  };
+  const sessionTaskState = initSessionState(sessionTaskStateScope, configuredTaskMetadata);
   const initialStatusLine =
     renderStatusLine(
       {
         model: sessionTaskState.model,
         effort: sessionTaskState.effort,
-        agent: getAgentDisplayName({
-          subAgentOptions,
-          agentId: route.agentId,
-          agentsList: cfg.agents?.list,
-        }),
+        agent: agentDisplayName,
       },
       dingtalkConfig,
     ) || undefined;
@@ -966,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;
@@ -987,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;
     };
   }
 
@@ -2175,7 +2260,7 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
         legacyCardStreamReasoning === undefined
           ? dingtalkConfig
           : { ...dingtalkConfig, cardStreamReasoning: legacyCardStreamReasoning };
-      const sessionTaskState = getSessionState(accountId, taskInfoConversationId);
+      const sessionTaskState = getSessionState(sessionTaskStateScope);
       const taskMeta = {
         model: sessionTaskState?.model,
         effort: sessionTaskState?.effort,
@@ -2183,11 +2268,7 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
           typeof sessionTaskState?.taskStartTime === "number"
             ? Math.max(0, Date.now() - sessionTaskState.taskStartTime)
             : undefined,
-        agent: getAgentDisplayName({
-          subAgentOptions,
-          agentId: route.agentId,
-          agentsList: cfg.agents?.list,
-        }),
+        agent: agentDisplayName,
       };
 
       const strategy = createReplyStrategy({
@@ -2250,6 +2331,7 @@ async function handleDingTalkMessageInner(params: HandleDingTalkMessageParams):
                   mediaUrls,
                   audioAsVoice: extractSharedAudioAsVoice(payload, inlineReplyPayload),
                   kind: replyKind,
+                  isError: payload.isError === true,
                   isReasoning: richPayload.isReasoning === true,
                 });
               } catch (err: unknown) {

package/src/reply-strategy-card.ts

@@ -49,6 +49,14 @@ export function createCardReplyStrategy(
   ctx: ReplyStrategyContext & { card: AICardInstance; isStopRequested?: () => boolean },
 ): ReplyStrategy {
   const { card, config, log, isStopRequested } = ctx;
+  const sessionTaskStateScope =
+    card.accountId && card.conversationId && ctx.sessionAgentId
+      ? {
+          accountId: card.accountId,
+          conversationId: card.contextConversationId || card.conversationId,
+          agentId: ctx.sessionAgentId,
+        }
+      : undefined;
 
   const buildStatusLine = (): string | undefined => {
     if (!ctx.taskMeta) {
@@ -61,8 +69,8 @@ export function createCardReplyStrategy(
           ? ctx.taskMeta.usage
           : undefined;
 
-    const sessionTaskTimeSeconds = card.accountId && card.conversationId
-      ? getTaskTimeSeconds(card.accountId, card.contextConversationId || card.conversationId)
+    const sessionTaskTimeSeconds = sessionTaskStateScope
+      ? getTaskTimeSeconds(sessionTaskStateScope)
       : undefined;
     const cardElapsedMs = Math.max(0, Date.now() - card.createdAt);
     const sessionElapsedMs = typeof sessionTaskTimeSeconds === "number"
@@ -439,10 +447,12 @@ export function createCardReplyStrategy(
           if (!card.accountId || !card.conversationId) {
             return;
           }
-          updateSessionState(card.accountId, card.contextConversationId || card.conversationId, {
-            model: selected.model,
-            effort: selected.thinkLevel,
-          });
+          if (sessionTaskStateScope) {
+            updateSessionState(sessionTaskStateScope, {
+              model: selected.model,
+              effort: selected.thinkLevel,
+            });
+          }
           if (ctx.taskMeta) {
             ctx.taskMeta.model = selected.model;
             ctx.taskMeta.effort = selected.thinkLevel;
@@ -470,6 +480,20 @@ export function createCardReplyStrategy(
 
       // ---- final: defer to finalize, just save text ----
       if (payload.kind === "final") {
+        // OpenClaw can append a non-terminal tool warning after a valid final.
+        // Do not let that plain-text warning replace the answer already captured by the card.
+        const hasPreservableReply = Boolean(
+          finalTextForFallback?.trim() || controller.getFinalAnswerContent().trim(),
+        ) || processedMediaUrls.size > 0 || pendingNonImageMedia.length > 0;
+        if (
+          payload.isError === true
+          && sawFinalDelivery
+          && payload.mediaUrls.length === 0
+          && hasPreservableReply
+        ) {
+          log?.debug?.("[DingTalk][Finalize] Ignoring late error final after answer delivery");
+          return;
+        }
         const isFirstFinalDelivery = !sawFinalDelivery;
         lifecycleState = "final_seen";
         await flushPendingReasoning();

package/src/reply-strategy-types.ts

@@ -30,6 +30,7 @@ export interface DeliverPayload {
    */
   audioAsVoice?: boolean;
   kind: "block" | "final" | "tool";
+  isError?: boolean;
   isReasoning?: boolean;
 }
 

package/src/session-state.ts

@@ -4,36 +4,67 @@ interface SessionState {
   taskStartTime: number;
 }
 
+interface SessionStateScope {
+  accountId: string;
+  conversationId: string;
+  agentId: string;
+}
+
+type SessionStateInitialMetadata = Partial<Pick<SessionState, "model" | "effort">>;
+
 const sessionStore = new Map<string, SessionState>();
 
-function sessionKey(accountId: string, conversationId: string): string {
-  return `${accountId}:${conversationId}`;
+function sessionKey(scope: SessionStateScope): string {
+  return `${scope.accountId}:${scope.agentId}:${scope.conversationId}`;
+}
+
+function normalizeMetadataValue(value: string | undefined): string | undefined {
+  const trimmed = typeof value === "string" ? value.trim() : "";
+  return trimmed || undefined;
+}
+
+function seedMissingSessionStateMetadata(
+  state: SessionState,
+  metadata?: SessionStateInitialMetadata,
+): void {
+  const model = normalizeMetadataValue(metadata?.model);
+  const effort = normalizeMetadataValue(metadata?.effort);
+  if (state.model === undefined && model !== undefined) {
+    state.model = model;
+  }
+  if (state.effort === undefined && effort !== undefined) {
+    state.effort = effort;
+  }
 }
 
-export function initSessionState(accountId: string, conversationId: string): SessionState {
-  const key = sessionKey(accountId, conversationId);
+export function initSessionState(
+  scope: SessionStateScope,
+  metadata?: SessionStateInitialMetadata,
+): SessionState {
+  const key = sessionKey(scope);
   const existing = sessionStore.get(key);
   if (existing) {
     existing.taskStartTime = Date.now();
+    seedMissingSessionStateMetadata(existing, metadata);
     return existing;
   }
   const state: SessionState = {
     taskStartTime: Date.now(),
   };
+  seedMissingSessionStateMetadata(state, metadata);
   sessionStore.set(key, state);
   return state;
 }
 
-export function getSessionState(accountId: string, conversationId: string): SessionState | undefined {
-  return sessionStore.get(sessionKey(accountId, conversationId));
+export function getSessionState(scope: SessionStateScope): SessionState | undefined {
+  return sessionStore.get(sessionKey(scope));
 }
 
 export function updateSessionState(
-  accountId: string,
-  conversationId: string,
+  scope: SessionStateScope,
   patch: Partial<Pick<SessionState, "model" | "effort">>,
 ): void {
-  const state = sessionStore.get(sessionKey(accountId, conversationId));
+  const state = sessionStore.get(sessionKey(scope));
   if (!state) {
     return;
   }
@@ -45,16 +76,16 @@ export function updateSessionState(
   }
 }
 
-export function getTaskTimeSeconds(accountId: string, conversationId: string): number | undefined {
-  const state = sessionStore.get(sessionKey(accountId, conversationId));
+export function getTaskTimeSeconds(scope: SessionStateScope): number | undefined {
+  const state = sessionStore.get(sessionKey(scope));
   if (!state) {
     return undefined;
   }
   return Math.round((Date.now() - state.taskStartTime) / 1000);
 }
 
-export function clearSessionState(accountId: string, conversationId: string): void {
-  sessionStore.delete(sessionKey(accountId, conversationId));
+export function clearSessionState(scope: SessionStateScope): void {
+  sessionStore.delete(sessionKey(scope));
 }
 
 export function clearAllSessionStatesForTest(): void {

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.