@soimy/dingtalk 3.5.2 → 3.6.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.5.2",
+  "version": "3.6.0",
   "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-markdown-image-reroute.ts

@@ -0,0 +1,106 @@
+export type MarkdownImageUrlClassification = "public" | "local" | "unsupported";
+
+export interface MarkdownImageCandidate {
+  alt: string;
+  url: string;
+  raw: string;
+  classification: MarkdownImageUrlClassification;
+  start: number;
+  end: number;
+}
+
+const MARKDOWN_IMAGE_RE = /!\[([^\]]*)\]\(([^)]+)\)/g;
+const PRIVATE_HOST_RE = /^(?:localhost|127\.0\.0\.1|10\.\d+\.\d+\.\d+|192\.168\.\d+\.\d+|172\.(?:1[6-9]|2\d|3[0-1])\.\d+\.\d+)$/;
+
+function isLikelyPlainRelativePath(url: string): boolean {
+  return !/^[a-zA-Z][a-zA-Z\d+.-]*:/.test(url) && !url.startsWith("//");
+}
+
+function isLikelyLocalPath(url: string): boolean {
+  return url.startsWith("./") || url.startsWith("../") || url.startsWith("/") || isLikelyPlainRelativePath(url);
+}
+
+function safeFileNameFromUrl(url: string): string {
+  const trimmed = url.trim();
+  if (!trimmed) {
+    return "";
+  }
+
+  if (trimmed.startsWith("file://")) {
+    const withoutScheme = trimmed.slice("file://".length);
+    const segments = withoutScheme.split("/").filter(Boolean);
+    return segments.at(-1) ?? "";
+  }
+
+  if (isLikelyLocalPath(trimmed)) {
+    const segments = trimmed.split(/[\\/]/).filter(Boolean);
+    return segments.at(-1) ?? "";
+  }
+
+  try {
+    const parsed = new URL(trimmed);
+    const segments = parsed.pathname.split("/").filter(Boolean);
+    return segments.at(-1) ?? "";
+  } catch {
+    return "";
+  }
+}
+
+export function classifyMarkdownImageUrl(url: string): MarkdownImageUrlClassification {
+  const trimmed = url.trim();
+  if (!trimmed) {
+    return "unsupported";
+  }
+
+  if (trimmed.startsWith("file://") || isLikelyLocalPath(trimmed)) {
+    return "local";
+  }
+
+  try {
+    const parsed = new URL(trimmed);
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+      return "unsupported";
+    }
+    if (PRIVATE_HOST_RE.test(parsed.hostname)) {
+      return "local";
+    }
+    return "public";
+  } catch {
+    return "unsupported";
+  }
+}
+
+export function buildImagePlaceholderText(input: { alt: string; url: string }): string {
+  const alt = input.alt.trim();
+  if (alt) {
+    return `见下图${alt}`;
+  }
+
+  const fileName = safeFileNameFromUrl(input.url);
+  if (fileName) {
+    return `见下图${fileName}`;
+  }
+
+  return "见下图图片";
+}
+
+export function extractMarkdownImageCandidates(text: string): MarkdownImageCandidate[] {
+  const candidates: MarkdownImageCandidate[] = [];
+
+  for (const match of text.matchAll(MARKDOWN_IMAGE_RE)) {
+    const raw = match[0] ?? "";
+    const alt = match[1] ?? "";
+    const url = match[2] ?? "";
+    const start = match.index ?? 0;
+    candidates.push({
+      alt,
+      url,
+      raw,
+      classification: classifyMarkdownImageUrl(url),
+      start,
+      end: start + raw.length,
+    });
+  }
+
+  return candidates;
+}

package/src/card/card-run-registry.ts

@@ -61,6 +61,8 @@ export function registerCardRun(
     agentId: string;
     ownerUserId?: string;
     card?: AICardInstance;
+    /** Override registeredAt timestamp (useful for tests). */
+    registeredAt?: number;
   },
 ): void {
   const trimmed = outTrackId.trim();
@@ -74,7 +76,7 @@ export function registerCardRun(
     agentId: params.agentId,
     ownerUserId: params.ownerUserId,
     card: params.card,
-    registeredAt: Date.now(),
+    registeredAt: params.registeredAt ?? Date.now(),
   });
   ensureSweepTimer();
 }
@@ -90,6 +92,57 @@ export function resolveCardRun(outTrackId: string): CardRunRecord | null {
   return records.get(outTrackId.trim()) ?? null;
 }
 
+/**
+ * Find the most recently registered card run for a given account + conversation.
+ * Uses case-insensitive match of the conversationId within sessionKey.
+ *
+ * @param accountId - The DingTalk account ID
+ * @param conversationId - The target conversation ID (matches within sessionKey)
+ * @param options - Optional filtering criteria
+ * @param options.ownerUserId - If provided, only return runs owned by this user
+ */
+export function resolveCardRunByConversation(
+  accountId: string,
+  conversationId: string,
+  options?: { ownerUserId?: string },
+): CardRunRecord | null {
+  const lowerCid = conversationId.toLowerCase();
+  const targetOwner = options?.ownerUserId;
+  let latest: CardRunRecord | null = null;
+  for (const record of records.values()) {
+    if (record.accountId !== accountId) { continue; }
+    if (!record.sessionKey.toLowerCase().includes(lowerCid)) { continue; }
+    // If ownerUserId filter is specified, only match runs owned by that user
+    if (targetOwner !== undefined && record.ownerUserId !== targetOwner) { continue; }
+    if (!latest || record.registeredAt > latest.registeredAt) {
+      latest = record;
+    }
+  }
+  return latest;
+}
+
+/**
+ * Find the most recently registered card run for a given account + owner.
+ * This is a fallback query when conversationId is unavailable (e.g., sessionKey=-).
+ *
+ * @param accountId - The DingTalk account ID
+ * @param ownerUserId - The DingTalk userId of the card owner
+ */
+export function resolveCardRunByOwner(
+  accountId: string,
+  ownerUserId: string,
+): CardRunRecord | null {
+  let latest: CardRunRecord | null = null;
+  for (const record of records.values()) {
+    if (record.accountId !== accountId) { continue; }
+    if (record.ownerUserId !== ownerUserId) { continue; }
+    if (!latest || record.registeredAt > latest.registeredAt) {
+      latest = record;
+    }
+  }
+  return latest;
+}
+
 export function markCardRunStopRequested(outTrackId: string): void {
   const record = records.get(outTrackId.trim());
   if (record && !record.stopRequestedAt) {

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

@@ -1,6 +1,5 @@
 import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
-import { getAccessToken } from "../auth";
-import { finishStoppedAICard, hideCardStopButton } from "../card-service";
+import { finalizeStoppedAICard } from "../card-service";
 import { dispatchDingTalkCardStopCommand } from "../command/card-stop-command";
 import type { DingTalkConfig, Logger } from "../types";
 import { AICardStatus } from "../types";
@@ -31,7 +30,9 @@ export async function stopCardRun(params: {
     return { ok: true, status: "already-stopped", lastContent: record.card?.lastStreamedContent };
   }
 
-  const lastContent = record.card?.lastStreamedContent;
+  const lastContent = record.controller?.getRenderedContent?.() || record.card?.lastStreamedContent;
+  const lastBlockListJson =
+    record.controller?.getRenderedBlocks?.() || record.card?.lastBlockListJson;
 
   markCardRunStopRequested(params.outTrackId);
   record.controller?.stop();
@@ -64,13 +65,14 @@ export async function stopCardRun(params: {
     }
   }
 
-  // --- Phase 2: Finalize card via streaming API (isFinalize=true) ---
+  // --- Phase 2: Finalize card via instances API so V2 blockList/content stay consistent ---
   if (record.card) {
-    const stoppedContent = lastContent
-      ? `${lastContent}\n\n---\n*⏹️ 已停止*`
-      : "⏹️ 已停止";
     try {
-      await finishStoppedAICard(record.card, stoppedContent, params.log);
+      await finalizeStoppedAICard(record.card, {
+        reason: "⏹️ 已停止",
+        previousContent: lastContent,
+        previousBlockListJson: lastBlockListJson,
+      }, params.log);
     } catch (error) {
       params.log?.warn?.(
         `[${params.accountId}] [DingTalk][CardStop] failed to finalize stopped card: ${error instanceof Error ? error.message : String(error)}`,
@@ -78,17 +80,5 @@ export async function stopCardRun(params: {
     }
   }
 
-  // --- Phase 3: Hide stop button (with retry, consistent with finishAICard path) ---
-  if (params.config) {
-    try {
-      const token = await getAccessToken(params.config, params.log);
-      await hideCardStopButton(params.outTrackId, token, params.config);
-    } catch (error) {
-      params.log?.debug?.(
-        `[${params.accountId}] [DingTalk][CardStop] non-critical: failed to hide stop button: ${error instanceof Error ? error.message : String(error)}`,
-      );
-    }
-  }
-
   return { ok: true, status: nativeStopStatus ?? "stopped-pending", lastContent };
 }

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/card-template.ts

@@ -1,20 +1,31 @@
 /** Card variable value that shows the stop button. */
-export const STOP_ACTION_VISIBLE = "true";
+export const STOP_ACTION_VISIBLE = true;
 /** Card variable value that hides the stop button. */
-export const STOP_ACTION_HIDDEN = "false";
+export const STOP_ACTION_HIDDEN = false;
 
 export const BUILTIN_DINGTALK_CARD_TEMPLATE_ID =
-  process.env.DINGTALK_CARD_TEMPLATE_ID || "51cd8c7e-0e7e-4464-a795-5b81499ada7a.schema";
+  process.env.DINGTALK_CARD_TEMPLATE_ID || "675cde2f-f526-40cb-b828-f5b2b57b8b77.schema";
 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 interface DingTalkCardTemplateContract {
   templateId: string;
   contentKey: string;
+  /** V2: key for the streaming markdown field (same as contentKey). */
+  streamingKey: string;
+  /** V2: key for the block-list loopArray variable. */
+  blockListKey: string;
+  /** V2: key for the plain-text copy content variable (String type for card copy action). */
+  copyContentKey: string;
 }
 
 /** Frozen singleton — no allocation on every call. */
 export const DINGTALK_CARD_TEMPLATE: Readonly<DingTalkCardTemplateContract> = Object.freeze({
   templateId: BUILTIN_DINGTALK_CARD_TEMPLATE_ID,
   contentKey: BUILTIN_DINGTALK_CARD_CONTENT_KEY,
+  streamingKey: BUILTIN_DINGTALK_CARD_CONTENT_KEY,
+  blockListKey: BUILTIN_DINGTALK_CARD_BLOCK_LIST_KEY,
+  copyContentKey: BUILTIN_DINGTALK_CARD_COPY_CONTENT_KEY,
 });
 

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/statusline-renderer.ts

@@ -0,0 +1,94 @@
+export function formatTokenCount(n: number): string {
+  if (n >= 1_000_000) {
+    return `${(n / 1_000_000).toFixed(1)}M`;
+  }
+  if (n >= 1_000) {
+    return `${(n / 1_000).toFixed(1)}k`;
+  }
+  return String(n);
+}
+
+export function formatDuration(seconds: number): string {
+  if (seconds < 60) {
+    return `${seconds}s`;
+  }
+  const m = Math.floor(seconds / 60);
+  const s = seconds % 60;
+  return `${m}m ${s}s`;
+}
+
+export interface StatusLineData {
+  model?: string;
+  effort?: string;
+  agent?: string;
+  taskTime?: number;
+  inputTokens?: number;
+  outputTokens?: number;
+  cacheRead?: number;
+  dapi_usage?: number;
+}
+
+export interface StatusLineConfig {
+  cardStatusLine?: {
+    model?: boolean;
+    effort?: boolean;
+    agent?: boolean;
+    taskTime?: boolean;
+    tokens?: boolean;
+    dapiUsage?: boolean;
+  };
+}
+
+type SegmentKey = "model" | "effort" | "agent" | "tokens" | "taskTime" | "dapiUsage";
+
+interface Segment {
+  key: SegmentKey;
+  defaultOn: boolean;
+  render: (d: StatusLineData) => string | undefined;
+}
+
+function renderTokenSegment(data: StatusLineData): string | undefined {
+  const parts: string[] = [];
+  if (typeof data.inputTokens === "number") {
+    let s = `↑${formatTokenCount(data.inputTokens)}`;
+    if (typeof data.cacheRead === "number" && data.cacheRead > 0) {
+      s += `(C:${formatTokenCount(data.cacheRead)})`;
+    }
+    parts.push(s);
+  }
+  if (typeof data.outputTokens === "number") {
+    parts.push(`↓${formatTokenCount(data.outputTokens)}`);
+  }
+  return parts.length > 0 ? parts.join(" ") : undefined;
+}
+
+const SEGMENTS: Segment[] = [
+  { key: "model", defaultOn: true, render: (d) => d.model || undefined },
+  { key: "effort", defaultOn: true, render: (d) => d.effort || undefined },
+  { key: "agent", defaultOn: true, render: (d) => d.agent || undefined },
+  { key: "tokens", defaultOn: false, render: renderTokenSegment },
+  { key: "taskTime", defaultOn: false, render: (d) => typeof d.taskTime === "number" ? formatDuration(d.taskTime) : undefined },
+  { key: "dapiUsage", defaultOn: false, render: (d) => typeof d.dapi_usage === "number" ? `DAPI+${d.dapi_usage}` : undefined },
+];
+
+const SEGMENTS_PER_LINE = 3;
+
+function resolveSegmentEnabled(seg: Segment, config: StatusLineConfig): boolean {
+  const value = config.cardStatusLine?.[seg.key];
+  return typeof value === "boolean" ? value : seg.defaultOn;
+}
+
+export function renderStatusLine(data: StatusLineData, config: StatusLineConfig): string {
+  const rendered = SEGMENTS
+    .filter((seg) => resolveSegmentEnabled(seg, config))
+    .map((seg) => seg.render(data))
+    .filter(Boolean) as string[];
+
+  if (rendered.length === 0) { return ""; }
+
+  const lines: string[] = [];
+  for (let i = 0; i < rendered.length; i += SEGMENTS_PER_LINE) {
+    lines.push(rendered.slice(i, i + SEGMENTS_PER_LINE).join(" | "));
+  }
+  return lines.join("\n");
+}