@soimy/dingtalk 3.5.2 → 3.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.5.2",
+  "version": "3.5.3",
   "description": "DingTalk (钉钉) channel plugin for OpenClaw",
   "keywords": [
     "bot",
@@ -64,7 +64,7 @@
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.3.24"
+    "openclaw": ">=2026.3.28"
   },
   "peerDependenciesMeta": {
     "openclaw": {
@@ -73,10 +73,10 @@
   },
   "openclaw": {
     "compat": {
-      "pluginApi": ">=2026.3.24"
+      "pluginApi": ">=2026.3.28"
     },
     "build": {
-      "openclawVersion": "2026.3.24"
+      "openclawVersion": "2026.3.28"
     },
     "extensions": [
       "./index.ts"
@@ -99,7 +99,7 @@
       ]
     },
     "install": {
-      "minHostVersion": ">=2026.3.24",
+      "minHostVersion": ">=2026.3.28",
       "npmSpec": "@soimy/dingtalk",
       "localPath": ".",
       "defaultChoice": "npm"

package/src/card/card-streaming-mode.ts

@@ -0,0 +1,30 @@
+import type { DingTalkConfig } from "../types";
+
+export type CardStreamingMode = "off" | "answer" | "all";
+
+// Process-lifetime one-shot warnings are intentional here: a given config key
+// should only emit the deprecation notice once per runtime.
+const warnedLegacyConfigs = new Set<string>();
+
+export function resolveCardStreamingMode(
+  config: Pick<DingTalkConfig, "cardStreamingMode" | "cardRealTimeStream">,
+): {
+  mode: CardStreamingMode;
+  usedDeprecatedCardRealTimeStream: boolean;
+} {
+  if (config.cardStreamingMode) {
+    return { mode: config.cardStreamingMode, usedDeprecatedCardRealTimeStream: false };
+  }
+  if (config.cardRealTimeStream === true) {
+    return { mode: "all", usedDeprecatedCardRealTimeStream: true };
+  }
+  return { mode: "off", usedDeprecatedCardRealTimeStream: false };
+}
+
+export function shouldWarnDeprecatedCardRealTimeStreamOnce(configKey: string): boolean {
+  if (warnedLegacyConfigs.has(configKey)) {
+    return false;
+  }
+  warnedLegacyConfigs.add(configKey);
+  return true;
+}

package/src/card/reasoning-answer-split.ts

@@ -0,0 +1,162 @@
+export interface CardReasoningAnswerSplit {
+    reasoningText?: string;
+    answerText?: string;
+}
+
+const THINKING_TAG_RE = /<\s*(\/?)\s*(?:think(?:ing)?|thought|antthinking)\b[^<>]*>/gi;
+
+function isWrappedReasoningLine(line: string): boolean {
+    const trimmed = line.trim();
+    return trimmed.startsWith("_") && trimmed.endsWith("_") && trimmed.length >= 3;
+}
+
+function cleanReasoningLine(line: string): string {
+    const trimmed = line.trim();
+    if (!trimmed) {
+        return "";
+    }
+    return trimmed.replace(/^_/, "").replace(/_$/, "").trim();
+}
+
+function joinAnswerParts(parts: string[]): string | undefined {
+    const joined = parts.map((part) => part.trim()).filter(Boolean).join("\n\n").trim();
+    return joined || undefined;
+}
+
+function hasStructuredMarkdown(text: string): boolean {
+    const trimmed = text.trim();
+    if (!trimmed) {
+        return false;
+    }
+    return (
+        trimmed.includes("**")
+        || trimmed.includes("```")
+        || /(^|\n)\s*(?:[-*+]\s|#{1,6}\s|>\s|\d+\.\s)/.test(trimmed)
+    );
+}
+
+function splitTopLevelReasoningPrefix(text: string): CardReasoningAnswerSplit | null {
+    const markerIndex = text.indexOf("Reasoning:");
+    if (markerIndex < 0) {
+        return null;
+    }
+
+    const before = text.slice(0, markerIndex).trim();
+    if (before && hasStructuredMarkdown(before)) {
+        return {
+            answerText: text,
+        };
+    }
+
+    const trailing = text.slice(markerIndex + "Reasoning:".length);
+    const lines = trailing.split("\n");
+    const reasoningLines: string[] = [];
+    let started = false;
+    let remainderIndex = -1;
+
+    for (let index = 0; index < lines.length; index += 1) {
+        const line = lines[index];
+        const trimmed = line.trim();
+
+        if (!started) {
+            if (!trimmed) {
+                continue;
+            }
+            if (!isWrappedReasoningLine(trimmed)) {
+                return {
+                    answerText: text,
+                };
+            }
+            started = true;
+            reasoningLines.push(cleanReasoningLine(trimmed));
+            continue;
+        }
+
+        if (!trimmed) {
+            continue;
+        }
+
+        if (isWrappedReasoningLine(trimmed)) {
+            reasoningLines.push(cleanReasoningLine(trimmed));
+            continue;
+        }
+
+        remainderIndex = index;
+        break;
+    }
+
+    if (reasoningLines.length === 0) {
+        return {
+            answerText: text,
+        };
+    }
+
+    const after = remainderIndex >= 0 ? lines.slice(remainderIndex).join("\n").trim() : "";
+    return {
+        reasoningText: reasoningLines.join("\n").trim() || undefined,
+        answerText: joinAnswerParts([before, after]),
+    };
+}
+
+function splitTopLevelThinkingTags(text: string): CardReasoningAnswerSplit | null {
+    if (!THINKING_TAG_RE.test(text)) {
+        return null;
+    }
+    THINKING_TAG_RE.lastIndex = 0;
+
+    let reasoning = "";
+    let answer = "";
+    let lastIndex = 0;
+    let inThinking = false;
+
+    for (const match of text.matchAll(THINKING_TAG_RE)) {
+        const matchIndex = match.index ?? 0;
+        const segment = text.slice(lastIndex, matchIndex);
+        if (inThinking) {
+            reasoning += segment;
+        } else {
+            answer += segment;
+        }
+        inThinking = match[1] !== "/";
+        lastIndex = matchIndex + match[0].length;
+    }
+
+    const tail = text.slice(lastIndex);
+    if (inThinking) {
+        reasoning += tail;
+    } else {
+        answer += tail;
+    }
+
+    const cleanedReasoning = reasoning.trim();
+    if (!cleanedReasoning) {
+        return {
+            answerText: text,
+        };
+    }
+
+    return {
+        reasoningText: cleanedReasoning,
+        answerText: answer.trim() || undefined,
+    };
+}
+
+export function splitCardReasoningAnswerText(text?: string): CardReasoningAnswerSplit {
+    if (typeof text !== "string") {
+        return {};
+    }
+
+    const prefixed = splitTopLevelReasoningPrefix(text);
+    if (prefixed) {
+        return prefixed;
+    }
+
+    const tagged = splitTopLevelThinkingTags(text);
+    if (tagged) {
+        return tagged;
+    }
+
+    return {
+        answerText: text,
+    };
+}

package/src/card-draft-controller.ts

@@ -22,15 +22,18 @@ type TimelineEntry = {
 };
 
 export interface CardDraftController {
-    updateAnswer: (text: string) => Promise<void>;
+    updateAnswer: (text: string, options?: { stream?: boolean }) => Promise<void>;
     updateReasoning: (text: string) => Promise<void>;
     updateThinking: (text: string) => Promise<void>;
     appendThinkingBlock: (text: string) => Promise<void>;
     updateTool: (text: string) => Promise<void>;
     appendTool: (text: string) => Promise<void>;
+    appendToolBeforeCurrentAnswer: (text: string) => Promise<void>;
     /** Signal that a new assistant turn has started (e.g. after a tool call). */
     notifyNewAssistantTurn: () => Promise<void>;
     startAssistantTurn: () => Promise<void>;
+    /** Seal the active thinking entry (keep it in timeline) without removing it. */
+    sealActiveThinking: () => Promise<void>;
     flush: () => Promise<void>;
     waitForInFlight: () => Promise<void>;
     stop: () => void;
@@ -78,6 +81,8 @@ export function createCardDraftController(params: {
     let failed = false;
     let stopped = false;
     let lastSentContent = "";
+    let lastQueuedContent = "";
+    let inFlightContent = "";
     let lastAnswerContent = "";
 
     let timelineEntries: TimelineEntry[] = [];
@@ -121,6 +126,15 @@ export function createCardDraftController(params: {
         return activeAnswerIndex;
     };
 
+    const findLastAnswerEntryIndex = (): number | null => {
+        for (let index = timelineEntries.length - 1; index >= 0; index -= 1) {
+            if (timelineEntries[index]?.kind === "answer") {
+                return index;
+            }
+        }
+        return null;
+    };
+
     const renderTimeline = (options: {
         fallbackAnswer?: string;
         overrideAnswer?: string;
@@ -179,13 +193,29 @@ export function createCardDraftController(params: {
         activeAnswerIndex = null;
     };
 
+    const clearPendingRender = () => {
+        loop.resetPending();
+        lastQueuedContent = "";
+    };
+
     const queueRender = () => {
         const rendered = renderTimeline({ compactProcessAnswerSpacing: true });
-        if (rendered) {
-            loop.update(rendered);
+        if (!rendered) {
+            clearPendingRender();
             return;
         }
-        loop.resetPending();
+        if (rendered === lastSentContent) {
+            const hasNewerInFlight = !!inFlightContent && inFlightContent !== rendered;
+            if (!hasNewerInFlight) {
+                clearPendingRender();
+                return;
+            }
+        }
+        if (rendered === lastQueuedContent) {
+            return;
+        }
+        lastQueuedContent = rendered;
+        loop.update(rendered);
     };
 
     const flushBoundaryFrame = async () => {
@@ -220,14 +250,20 @@ export function createCardDraftController(params: {
         throttleMs: effectiveThrottleMs,
         isStopped: () => stopped || failed,
         sendOrEditStreamMessage: async (content: string) => {
+            inFlightContent = content;
             try {
                 await streamAICard(params.card, content, false, params.log);
                 lastSentContent = content;
+                lastQueuedContent = "";
                 lastAnswerContent = getFinalAnswerContent();
             } catch (err: unknown) {
                 failed = true;
                 const message = err instanceof Error ? err.message : String(err);
                 params.log?.warn?.(`[DingTalk][AICard] Stream failed: ${message}`);
+            } finally {
+                if (inFlightContent === content) {
+                    inFlightContent = "";
+                }
             }
         },
     });
@@ -255,7 +291,7 @@ export function createCardDraftController(params: {
         queueRender();
     };
 
-    const updateAnswer = async (text: string) => {
+    const updateAnswer = async (text: string, options: { stream?: boolean } = {}) => {
         await waitForPendingBoundary();
         if (stopped || failed) {
             return;
@@ -276,6 +312,10 @@ export function createCardDraftController(params: {
         } else {
             activeAnswerIndex = appendTimelineEntry("answer", normalized);
         }
+        if (options.stream === false) {
+            clearPendingRender();
+            return;
+        }
         queueRender();
     };
 
@@ -323,6 +363,35 @@ export function createCardDraftController(params: {
         queueRender();
     };
 
+    const appendToolBeforeCurrentAnswer = async (text: string) => {
+        await waitForPendingBoundary();
+        if (stopped || failed) {
+            return;
+        }
+        const normalized = normalizeProcessText(text);
+        if (!normalized) {
+            return;
+        }
+        if (timelineEntries.length > 0) {
+            await flushBoundaryFrame();
+        }
+        sealLiveThinking();
+        const insertionIndex = findCurrentSegmentAnswerIndex() ?? findLastAnswerEntryIndex();
+        if (insertionIndex !== null) {
+            timelineEntries.splice(insertionIndex, 0, { kind: "tool", text: normalized });
+            if (activeAnswerIndex !== null && activeAnswerIndex >= insertionIndex) {
+                activeAnswerIndex += 1;
+            }
+            if (activeThinkingIndex !== null && activeThinkingIndex >= insertionIndex) {
+                activeThinkingIndex += 1;
+            }
+        } else {
+            sealCurrentAnswer();
+            appendTimelineEntry("tool", normalized);
+        }
+        queueRender();
+    };
+
     const notifyNewAssistantTurn = async () => {
         if (stopped || failed) {
             return;
@@ -334,7 +403,7 @@ export function createCardDraftController(params: {
         }
         if (activeThinkingIndex !== null) {
             removeTimelineEntry(activeThinkingIndex);
-            loop.resetPending();
+            clearPendingRender();
         }
     };
 
@@ -345,8 +414,18 @@ export function createCardDraftController(params: {
         appendThinkingBlock,
         updateTool,
         appendTool: updateTool,
+        appendToolBeforeCurrentAnswer,
         notifyNewAssistantTurn,
         startAssistantTurn: notifyNewAssistantTurn,
+        sealActiveThinking: async () => {
+            if (stopped || failed) {
+                return;
+            }
+            if (activeThinkingIndex !== null) {
+                sealLiveThinking();
+                await beginBoundaryFlush();
+            }
+        },
         flush: () => loop.flush(),
         waitForInFlight: () => loop.waitForInFlight(),
 

package/src/card-service.ts

@@ -904,6 +904,117 @@ export async function finishAICard(
   }
 }
 
+function getCardRecallTarget(card: AICardInstance): {
+  isGroup: boolean;
+  conversationId?: string;
+} {
+  const { targetId, isExplicitUser } = stripTargetPrefix(card.conversationId);
+  const resolvedTarget = resolveOriginalPeerId(targetId);
+  const isGroup = !isExplicitUser && resolvedTarget.startsWith("cid");
+  return {
+    isGroup,
+    conversationId: resolvedTarget || undefined,
+  };
+}
+
+function parseRecallFailureEntries(payload: unknown): Array<[string, string]> {
+  if (!payload || typeof payload !== "object") {
+    return [];
+  }
+  return Object.entries(payload as Record<string, unknown>)
+    .map(([key, value]) => [String(key), String(value ?? "")] as [string, string]);
+}
+
+export async function recallAICardMessage(
+  card: AICardInstance,
+  log?: Logger,
+): Promise<boolean> {
+  const config = card.config;
+  const processQueryKey = card.processQueryKey?.trim();
+  const robotCode = config ? resolveRobotCode(config) : "";
+
+  if (!config || !processQueryKey || !robotCode) {
+    log?.warn?.(
+      `[DingTalk][AICard] Skip recall because required metadata is missing: ` +
+      `card=${card.cardInstanceId} hasConfig=${Boolean(config)} ` +
+      `processQueryKey=${processQueryKey || "(none)"} robotCode=${robotCode || "(none)"}`,
+    );
+    return false;
+  }
+
+  const target = getCardRecallTarget(card);
+  if (!target.conversationId) {
+    log?.warn?.(
+      `[DingTalk][AICard] Skip recall because conversationId is invalid: card=${card.cardInstanceId} conversationId=${card.conversationId}`,
+    );
+    return false;
+  }
+
+  const url = target.isGroup
+    ? `${DINGTALK_API}/v1.0/robot/groupMessages/recall`
+    : `${DINGTALK_API}/v1.0/robot/otoMessages/batchRecall`;
+  const body: Record<string, unknown> = {
+    robotCode,
+    processQueryKeys: [processQueryKey],
+  };
+  if (target.isGroup) {
+    body.openConversationId = target.conversationId;
+  }
+
+  try {
+    const token = await getAccessToken(config, log);
+    const response = await axios.post(url, body, {
+      headers: {
+        "x-acs-dingtalk-access-token": token,
+        "Content-Type": "application/json",
+      },
+      ...getProxyBypassOption(config),
+    });
+    const successResults = Array.isArray((response.data as Record<string, unknown> | undefined)?.successResult)
+      ? ((response.data as Record<string, unknown>).successResult as unknown[])
+          .map((item) => String(item))
+      : [];
+    const failedEntries = parseRecallFailureEntries(
+      (response.data as Record<string, unknown> | undefined)?.failedResult,
+    );
+    if (failedEntries.length > 0) {
+      log?.warn?.(
+        `[DingTalk][AICard] Recall reported failedResult: card=${card.cardInstanceId} ` +
+        `processQueryKey=${processQueryKey} failed=${JSON.stringify(failedEntries)}`,
+      );
+      return false;
+    }
+    if (!successResults.includes(processQueryKey)) {
+      log?.warn?.(
+        `[DingTalk][AICard] Recall response missing successResult for processQueryKey=${processQueryKey} ` +
+        `payload=${JSON.stringify(response.data)}`,
+      );
+      return false;
+    }
+
+    card.state = AICardStatus.FINISHED;
+    card.lastUpdated = Date.now();
+    removePendingCard(card, log);
+    log?.info?.(
+      `[DingTalk][AICard] Recalled empty card message: card=${card.cardInstanceId} ` +
+      `conversationId=${target.conversationId} processQueryKey=${processQueryKey} mode=${target.isGroup ? "group" : "direct"}`,
+    );
+    return true;
+  } catch (err: any) {
+    log?.warn?.(`[DingTalk][AICard] Recall failed for card=${card.cardInstanceId}: ${err.message}`);
+    if (err.response?.data !== undefined) {
+      log?.warn?.(
+        formatDingTalkErrorPayloadLog(
+          target.isGroup ? "card.groupRecall" : "card.directRecall",
+          err.response.data,
+          "[DingTalk][AICard]",
+        ),
+      );
+    }
+    return false;
+  }
+}
+
 export async function finishStoppedAICard(
   card: AICardInstance,
   content: string,