@soimy/dingtalk 3.6.4 → 3.6.6

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 =
+  "c2a6355b-9724-4f7e-9653-d33fcb3311bb.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/card/task-model-metadata.ts

@@ -0,0 +1,51 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
+
+export interface InitialTaskModelMetadata {
+  model?: string;
+  effort?: string;
+}
+
+type AgentModelConfigLike = string | { primary?: unknown } | undefined;
+
+function readPrimaryModelRef(value: AgentModelConfigLike): string | undefined {
+  if (typeof value === "string") {
+    return value.trim() || undefined;
+  }
+  if (value && typeof value === "object" && typeof value.primary === "string") {
+    return value.primary.trim() || undefined;
+  }
+  return undefined;
+}
+
+export function normalizeModelDisplayName(modelRef: string | undefined): string | undefined {
+  const trimmed = typeof modelRef === "string" ? modelRef.trim() : "";
+  if (!trimmed) {
+    return undefined;
+  }
+  const parts = trimmed.split("/").map((part) => part.trim()).filter(Boolean);
+  return parts.at(-1) || undefined;
+}
+
+export function resolveConfiguredTaskModelMetadata(params: {
+  cfg: OpenClawConfig;
+  agentId?: string | null;
+}): InitialTaskModelMetadata {
+  const agents = params.cfg.agents;
+  const agentId = String(params.agentId || "").trim();
+  const agent = Array.isArray(agents?.list)
+    ? agents.list.find((entry) => String(entry.id || "").trim() === agentId)
+    : undefined;
+
+  const modelRef = readPrimaryModelRef(agent?.model) ?? readPrimaryModelRef(agents?.defaults?.model);
+  const effort =
+    typeof agent?.thinkingDefault === "string" && agent.thinkingDefault.trim()
+      ? agent.thinkingDefault.trim()
+      : typeof agents?.defaults?.thinkingDefault === "string" && agents.defaults.thinkingDefault.trim()
+        ? agents.defaults.thinkingDefault.trim()
+        : undefined;
+
+  return {
+    model: normalizeModelDisplayName(modelRef),
+    effort,
+  };
+}

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,20 @@ 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 { resolveConfiguredTaskModelMetadata } from "./card/task-model-metadata";
+import { dispatchDingTalkCardStopCommand } from "./command/card-stop-command";
 import { handleInboundCommandDispatch } from "./command/inbound-command-dispatch-service";
 import {
   resolveAckReactionSetting,
@@ -418,6 +429,7 @@ function buildGroupTurnContextPrompt(params: {
 
 type ReplyStreamPayload = {
   text?: string;
+  isError?: boolean;
   isReasoning?: boolean;
   mediaUrl?: string;
   mediaUrls?: string[];
@@ -548,6 +560,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,
@@ -809,6 +838,10 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       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
@@ -905,17 +938,27 @@ export async function handleDingTalkMessage(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;
@@ -930,8 +973,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)) {
@@ -2100,7 +2187,7 @@ export async function handleDingTalkMessage(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,
@@ -2108,11 +2195,7 @@ export async function handleDingTalkMessage(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({
@@ -2163,11 +2246,19 @@ 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,
+                  isError: payload.isError === true,
                   isReasoning: richPayload.isReasoning === true,
                 });
               } catch (err: unknown) {
@@ -2212,13 +2303,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) {
@@ -2228,6 +2325,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

@@ -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 {