@soimy/dingtalk 3.5.3 → 3.6.0

package/index.ts

@@ -3,6 +3,7 @@ import { readStringParam } from "openclaw/plugin-sdk/param-readers";
 import { dingtalkPlugin } from "./src/channel";
 import { getConfig } from "./src/config";
 import { appendToDoc, createDoc, DocCreateAppendError, listDocs, searchDocs } from "./src/docs-service";
+import { accumulateUsage } from "./src/run-usage-store";
 import { setDingTalkRuntime } from "./src/runtime";
 
 type GatewayMethodContext = Pick<
@@ -81,5 +82,11 @@ export default defineChannelPluginEntry({
   setRuntime: setDingTalkRuntime,
   registerFull(api) {
     registerDingTalkDocsGatewayMethods(api);
+
+    api.on("llm_output", (event: { runId: string; usage?: { input?: number; output?: number; cacheRead?: number; cacheWrite?: number; total?: number } }) => {
+      if (event.usage) {
+        accumulateUsage(event.runId, event.usage);
+      }
+    });
   },
 });

package/openclaw.plugin.json

@@ -253,6 +253,44 @@
             "type": "string",
             "description": "Send a follow-up @mention text after card finalization in group chats. Any non-empty string becomes the message body."
           },
+          "cardStatusLine": {
+            "type": "object",
+            "description": "Status line visibility toggles for the AI card footer.",
+            "additionalProperties": false,
+            "default": { "model": true, "effort": true, "agent": true, "taskTime": false, "tokens": false, "dapiUsage": false },
+            "properties": {
+              "model": {
+                "type": "boolean",
+                "default": true,
+                "description": "Show model name in AI card status line footer."
+              },
+              "effort": {
+                "type": "boolean",
+                "default": true,
+                "description": "Show thinking effort level in AI card status line footer."
+              },
+              "agent": {
+                "type": "boolean",
+                "default": true,
+                "description": "Show agent display name in AI card status line footer."
+              },
+              "taskTime": {
+                "type": "boolean",
+                "default": false,
+                "description": "Show task elapsed time in AI card status line footer."
+              },
+              "tokens": {
+                "type": "boolean",
+                "default": false,
+                "description": "Show token usage summary (input/output/cache) in AI card status line footer."
+              },
+              "dapiUsage": {
+                "type": "boolean",
+                "default": false,
+                "description": "Show DingTalk API call count in AI card status line footer."
+              }
+            }
+          },
           "showThinkingStream": {
             "type": "boolean",
             "description": "Legacy compatibility field from older card streaming behavior. It is not used by the current runtime and new configs should omit it."
@@ -498,6 +536,44 @@
                 "cardAtSender": {
                   "type": "string",
                   "description": "Send a follow-up @mention text after card finalization in group chats. Any non-empty string becomes the message body."
+                },
+                "cardStatusLine": {
+                  "type": "object",
+                  "description": "Status line visibility toggles for the AI card footer.",
+                  "additionalProperties": false,
+                  "default": { "model": true, "effort": true, "agent": true, "taskTime": false, "tokens": false, "dapiUsage": false },
+                  "properties": {
+                    "model": {
+                      "type": "boolean",
+                      "default": true,
+                      "description": "Show model name in AI card status line footer."
+                    },
+                    "effort": {
+                      "type": "boolean",
+                      "default": true,
+                      "description": "Show thinking effort level in AI card status line footer."
+                    },
+                    "agent": {
+                      "type": "boolean",
+                      "default": true,
+                      "description": "Show agent display name in AI card status line footer."
+                    },
+                    "taskTime": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "Show task elapsed time in AI card status line footer."
+                    },
+                    "tokens": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "Show token usage summary (input/output/cache) in AI card status line footer."
+                    },
+                    "dapiUsage": {
+                      "type": "boolean",
+                      "default": false,
+                      "description": "Show DingTalk API call count in AI card status line footer."
+                    }
+                  }
                 }
               }
             }
@@ -678,6 +754,34 @@
           "label": "Card Mention Follow-Up",
           "help": "Send a follow-up @mention text after card finalization in group chats. Any non-empty string becomes the message body."
         },
+        "cardStatusLine": {
+          "label": "Status Line",
+          "help": "Configure which information segments appear in the AI card footer status line."
+        },
+        "cardStatusLine.model": {
+          "label": "Model Name",
+          "help": "Show the LLM model name in the AI card footer status line."
+        },
+        "cardStatusLine.effort": {
+          "label": "Thinking Effort",
+          "help": "Show the thinking effort level (e.g. high, medium) in the AI card footer."
+        },
+        "cardStatusLine.agent": {
+          "label": "Agent Name",
+          "help": "Show the agent display name in the AI card footer."
+        },
+        "cardStatusLine.taskTime": {
+          "label": "Task Time",
+          "help": "Show elapsed task time in the AI card footer."
+        },
+        "cardStatusLine.tokens": {
+          "label": "Token Usage",
+          "help": "Show a compact token usage summary (input/output/cache) in the AI card footer."
+        },
+        "cardStatusLine.dapiUsage": {
+          "label": "API Calls",
+          "help": "Show the DingTalk API call count in the AI card footer."
+        },
         "showThinkingStream": {
           "label": "Legacy Show Thinking Stream",
           "help": "Deprecated compatibility field from older card streaming behavior. The current runtime ignores it."

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.5.3",
+  "version": "3.6.0",
   "description": "DingTalk (钉钉) channel plugin for OpenClaw",
   "keywords": [
     "bot",

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-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/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");
+}