@soimy/dingtalk 3.5.1 → 3.5.3

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.5.1",
+  "version": "3.5.3",
   "description": "DingTalk (钉钉) channel plugin for OpenClaw",
   "keywords": [
     "bot",
@@ -46,7 +46,7 @@
     "type-check": "tsc -p tsconfig.json"
   },
   "dependencies": {
-    "axios": "^1.6.0",
+    "axios": "1.13.6",
     "dingtalk-stream": "^2.1.4",
     "form-data": "^4.0.0",
     "mammoth": "^1.12.0",
@@ -58,20 +58,25 @@
     "@vitest/coverage-v8": "^3.2.4",
     "oxfmt": "0.34.0",
     "oxlint": "^1.49.0",
-    "oxlint-tsgolint": "^0.15.0",
+    "oxlint-tsgolint": "^0.18.0",
     "typescript": "^5.3.0",
     "vitepress": "1.6.4",
     "vitest": "^3.2.4"
   },
   "peerDependencies": {
-    "openclaw": ">=2026.3.24"
+    "openclaw": ">=2026.3.28"
+  },
+  "peerDependenciesMeta": {
+    "openclaw": {
+      "optional": true
+    }
   },
   "openclaw": {
     "compat": {
-      "pluginApi": ">=2026.3.24"
+      "pluginApi": ">=2026.3.28"
     },
     "build": {
-      "openclawVersion": "2026.3.24"
+      "openclawVersion": "2026.3.28"
     },
     "extensions": [
       "./index.ts"
@@ -94,7 +99,7 @@
       ]
     },
     "install": {
-      "minHostVersion": ">=2026.3.24",
+      "minHostVersion": ">=2026.3.28",
       "npmSpec": "@soimy/dingtalk",
       "localPath": ".",
       "defaultChoice": "npm"

package/src/ack-reaction-service.ts

@@ -1,4 +1,4 @@
-import axios from "axios";
+import axios from "./http-client";
 import { getAccessToken } from "./auth";
 import type { DingTalkConfig } from "./types";
 import { formatDingTalkErrorPayloadLog, getErrorMessage, getProxyBypassOption } from "./utils";

package/src/auth.ts

@@ -1,4 +1,4 @@
-import axios from "axios";
+import axios from "./http-client";
 import type { DingTalkConfig, Logger, TokenInfo } from "./types";
 import { retryWithBackoff } from "./utils";
 

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

@@ -1,4 +1,4 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { CardCallbackAnalysis } from "../card-callback-service";
 import type { DingTalkConfig, Logger } from "../types";
 import { resolveCardRun } from "./card-run-registry";

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

@@ -1,4 +1,4 @@
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import { getAccessToken } from "../auth";
 import { finishStoppedAICard, hideCardStopButton } from "../card-service";
 import { dispatchDingTalkCardStopCommand } from "../command/card-stop-command";

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/reasoning-block-assembler.ts

@@ -0,0 +1,157 @@
+export interface ReasoningBlockAssembler {
+    ingestSnapshot: (text: string | undefined) => string[];
+    flushPendingAtBoundary: () => string[];
+    reset: () => void;
+}
+
+function stripReasoningPrefix(text: string): string {
+    const trimmed = text.trim();
+    if (trimmed.startsWith("Reasoning:")) {
+        return trimmed.slice("Reasoning:".length).trimStart();
+    }
+    return trimmed;
+}
+
+function cleanReasoningLine(line: string): string {
+    return line.trim().replace(/^_/, "").replace(/_$/, "").trim();
+}
+
+function isClosedReasoningLine(line: string): boolean {
+    const trimmed = line.trim();
+    return trimmed.startsWith("_") && trimmed.endsWith("_") && trimmed.length >= 2;
+}
+
+function startsReasonBlock(line: string): boolean {
+    return cleanReasoningLine(line).startsWith("Reason:");
+}
+
+function blocksStartWithPrefix(blocks: string[], prefix: string[]): boolean {
+    if (prefix.length > blocks.length) {
+        return false;
+    }
+    return prefix.every((entry, index) => blocks[index] === entry);
+}
+
+function parseReasoningSnapshot(text: string | undefined): {
+    completeBlocks: string[];
+    pendingBlock: string;
+} {
+    const normalized = typeof text === "string" ? stripReasoningPrefix(text) : "";
+    if (!normalized.trim()) {
+        return {
+            completeBlocks: [],
+            pendingBlock: "",
+        };
+    }
+
+    const lines = normalized
+        .split("\n")
+        .map((line) => line.trim())
+        .filter((line) => line.length > 0);
+
+    const completeBlocks: string[] = [];
+    let currentLines: string[] = [];
+    let currentMode: "explicit" | "implicit" | null = null;
+    let currentComplete = true;
+
+    const finalizeCurrent = () => {
+        if (currentLines.length === 0) {
+            return;
+        }
+        if (currentMode === "explicit" && currentComplete) {
+            completeBlocks.push(currentLines.join("\n"));
+        }
+    };
+
+    for (const line of lines) {
+        if (startsReasonBlock(line)) {
+            finalizeCurrent();
+            currentLines = [cleanReasoningLine(line)];
+            currentMode = "explicit";
+            currentComplete = isClosedReasoningLine(line);
+            continue;
+        }
+
+        if (currentLines.length === 0) {
+            const trimmedLine = line.trim();
+            const cleanedLine = cleanReasoningLine(line);
+            if (!cleanedLine) {
+                continue;
+            }
+            if (!trimmedLine.startsWith("_")) {
+                continue;
+            }
+            currentLines = [cleanedLine];
+            currentMode = "implicit";
+            currentComplete = false;
+            continue;
+        }
+
+        currentLines.push(cleanReasoningLine(line));
+        currentComplete = currentMode === "explicit"
+            ? currentComplete && isClosedReasoningLine(line)
+            : false;
+    }
+
+    if (currentLines.length === 0) {
+        return {
+            completeBlocks,
+            pendingBlock: "",
+        };
+    }
+
+    if (currentMode === "explicit" && currentComplete) {
+        completeBlocks.push(currentLines.join("\n"));
+        return {
+            completeBlocks,
+            pendingBlock: "",
+        };
+    }
+
+    return {
+        completeBlocks,
+        pendingBlock: currentLines.join("\n").trim(),
+    };
+}
+
+export function createReasoningBlockAssembler(): ReasoningBlockAssembler {
+    let emittedBlocks: string[] = [];
+    let pendingBlock = "";
+
+    return {
+        ingestSnapshot(text: string | undefined): string[] {
+            const parsed = parseReasoningSnapshot(text);
+            pendingBlock = parsed.pendingBlock;
+
+            if (parsed.completeBlocks.length === 0) {
+                return [];
+            }
+
+            if (blocksStartWithPrefix(parsed.completeBlocks, emittedBlocks)) {
+                const nextBlocks = parsed.completeBlocks.slice(emittedBlocks.length);
+                emittedBlocks = [...parsed.completeBlocks];
+                return nextBlocks;
+            }
+
+            if (blocksStartWithPrefix(emittedBlocks, parsed.completeBlocks)) {
+                return [];
+            }
+
+            return [];
+        },
+
+        flushPendingAtBoundary(): string[] {
+            if (!pendingBlock.trim()) {
+                return [];
+            }
+            const flushed = pendingBlock;
+            pendingBlock = "";
+            return [flushed];
+        },
+
+        reset(): void {
+            emittedBlocks = [];
+            pendingBlock = "";
+        },
+    };
+}

package/src/card-callback-service.ts

@@ -1,4 +1,4 @@
-import axios from "axios";
+import axios from "./http-client";
 import { getProxyBypassOption } from "./utils";
 
 const DINGTALK_API = "https://api.dingtalk.com";

package/src/card-draft-controller.ts

@@ -22,14 +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;
@@ -77,6 +81,8 @@ export function createCardDraftController(params: {
     let failed = false;
     let stopped = false;
     let lastSentContent = "";
+    let lastQueuedContent = "";
+    let inFlightContent = "";
     let lastAnswerContent = "";
 
     let timelineEntries: TimelineEntry[] = [];
@@ -116,6 +122,19 @@ export function createCardDraftController(params: {
         return timelineEntries.length - 1;
     };
 
+    const findCurrentSegmentAnswerIndex = (): number | null => {
+        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;
@@ -174,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 () => {
@@ -215,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 = "";
+                }
             }
         },
     });
@@ -250,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;
@@ -271,6 +312,10 @@ export function createCardDraftController(params: {
         } else {
             activeAnswerIndex = appendTimelineEntry("answer", normalized);
         }
+        if (options.stream === false) {
+            clearPendingRender();
+            return;
+        }
         queueRender();
     };
 
@@ -292,6 +337,61 @@ export function createCardDraftController(params: {
         queueRender();
     };
 
+    const appendThinkingBlock = async (text: string) => {
+        await waitForPendingBoundary();
+        if (stopped || failed) {
+            return;
+        }
+        const normalized = normalizeProcessText(text);
+        if (!normalized) {
+            return;
+        }
+        if (timelineEntries.length > 0) {
+            await flushBoundaryFrame();
+        }
+        sealLiveThinking();
+        const currentSegmentAnswerIndex = findCurrentSegmentAnswerIndex();
+        if (currentSegmentAnswerIndex !== null) {
+            timelineEntries.splice(currentSegmentAnswerIndex, 0, { kind: "thinking", text: normalized });
+            if (activeAnswerIndex !== null && activeAnswerIndex >= currentSegmentAnswerIndex) {
+                activeAnswerIndex += 1;
+            }
+        } else {
+            sealCurrentAnswer();
+            appendTimelineEntry("thinking", normalized);
+        }
+        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;
@@ -303,7 +403,7 @@ export function createCardDraftController(params: {
         }
         if (activeThinkingIndex !== null) {
             removeTimelineEntry(activeThinkingIndex);
-            loop.resetPending();
+            clearPendingRender();
         }
     };
 
@@ -311,10 +411,21 @@ export function createCardDraftController(params: {
         updateAnswer,
         updateReasoning,
         updateThinking: updateReasoning,
+        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(),