@soimy/dingtalk 3.5.0 → 3.5.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@soimy/dingtalk",
-  "version": "3.5.0",
+  "version": "3.5.1",
   "description": "DingTalk (钉钉) channel plugin for OpenClaw",
   "keywords": [
     "bot",
@@ -67,6 +67,12 @@
     "openclaw": ">=2026.3.24"
   },
   "openclaw": {
+    "compat": {
+      "pluginApi": ">=2026.3.24"
+    },
+    "build": {
+      "openclawVersion": "2026.3.24"
+    },
     "extensions": [
       "./index.ts"
     ],

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

@@ -0,0 +1,62 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import type { CardCallbackAnalysis } from "../card-callback-service";
+import type { DingTalkConfig, Logger } from "../types";
+import { resolveCardRun } from "./card-run-registry";
+import { stopCardRun } from "./card-stop-handler";
+
+export interface CardActionResult {
+  handled: boolean;
+}
+
+export async function handleCardAction(params: {
+  analysis: CardCallbackAnalysis;
+  cfg: OpenClawConfig;
+  accountId: string;
+  config: DingTalkConfig;
+  log?: Logger;
+}): Promise<CardActionResult> {
+  if (params.analysis.actionId !== "btn_stop") {
+    return { handled: false };
+  }
+
+  const outTrackId = params.analysis.outTrackId;
+  if (!outTrackId) {
+    params.log?.warn?.(
+      `[${params.accountId}] [DingTalk][CardStop] stop callback missing outTrackId — cannot route stop request`,
+    );
+    return { handled: false };
+  }
+
+  // In group chats, only the user who initiated the conversation can stop it.
+  // Fail-closed: reject when clicker identity is missing but owner is known.
+  const clickerUserId = params.analysis.userId;
+  const record = resolveCardRun(outTrackId);
+  if (record?.ownerUserId) {
+    if (!clickerUserId || record.ownerUserId !== clickerUserId) {
+      params.log?.info?.(
+        `[${params.accountId}] [DingTalk][CardStop] rejected: clicker=${clickerUserId ?? "unknown"} owner=${record.ownerUserId}`,
+      );
+      return { handled: true };
+    }
+  }
+
+  const result = await stopCardRun({
+    cfg: params.cfg,
+    accountId: params.accountId,
+    outTrackId,
+    config: params.config,
+    clickerUserId,
+    log: params.log,
+  });
+  if (!result.ok) {
+    params.log?.warn?.(
+      `[${params.accountId}] [DingTalk][CardStop] stop failed status=${result.status} reason=${result.reason ?? "unknown"}`,
+    );
+  } else {
+    params.log?.info?.(
+      `[${params.accountId}] [DingTalk][CardStop] stop succeeded outTrackId=${outTrackId}`,
+    );
+  }
+
+  return { handled: true };
+}

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

@@ -0,0 +1,118 @@
+/**
+ * In-process card run registry for tracking active AI card runs.
+ *
+ * DEPLOYMENT CONSTRAINT: This registry uses a process-local Map. In multi-process
+ * deployments (cluster/PM2), stop callbacks may route to a different worker than
+ * the one that created the card run, causing resolveCardRun to return null and
+ * the stop button to silently fail. Ensure single-process deployment or sticky
+ * routing per card callback when using the stop button feature.
+ */
+import type { CardDraftController } from "../card-draft-controller";
+import type { AICardInstance } from "../types";
+
+export interface CardRunRecord {
+  outTrackId: string;
+  accountId: string;
+  sessionKey: string;
+  /** OpenClaw agent ID resolved from the inbound route. */
+  agentId: string;
+  /** DingTalk userId of the user who initiated this card run. */
+  ownerUserId?: string;
+  card?: AICardInstance;
+  controller?: CardDraftController;
+  stopRequestedAt?: number;
+  registeredAt: number;
+}
+
+const CARD_RUN_TTL_MS = 30 * 60 * 1000;
+const SWEEP_INTERVAL_MS = 5 * 60 * 1000;
+
+const records = new Map<string, CardRunRecord>();
+
+let sweepTimer: ReturnType<typeof setInterval> | null = null;
+
+function ensureSweepTimer(): void {
+  if (sweepTimer) {
+    return;
+  }
+  sweepTimer = setInterval(() => {
+    const now = Date.now();
+    for (const [key, record] of records) {
+      if (now - record.registeredAt > CARD_RUN_TTL_MS) {
+        records.delete(key);
+      }
+    }
+    if (records.size === 0 && sweepTimer) {
+      clearInterval(sweepTimer);
+      sweepTimer = null;
+    }
+  }, SWEEP_INTERVAL_MS);
+  // Allow the process to exit without waiting for this timer.
+  if (typeof sweepTimer === "object" && "unref" in sweepTimer) {
+    sweepTimer.unref();
+  }
+}
+
+export function registerCardRun(
+  outTrackId: string,
+  params: {
+    accountId: string;
+    sessionKey: string;
+    agentId: string;
+    ownerUserId?: string;
+    card?: AICardInstance;
+  },
+): void {
+  const trimmed = outTrackId.trim();
+  if (!trimmed) {
+    return;
+  }
+  records.set(trimmed, {
+    outTrackId: trimmed,
+    accountId: params.accountId,
+    sessionKey: params.sessionKey,
+    agentId: params.agentId,
+    ownerUserId: params.ownerUserId,
+    card: params.card,
+    registeredAt: Date.now(),
+  });
+  ensureSweepTimer();
+}
+
+export function attachCardRunController(outTrackId: string, controller: CardDraftController): void {
+  const record = records.get(outTrackId.trim());
+  if (record) {
+    record.controller = controller;
+  }
+}
+
+export function resolveCardRun(outTrackId: string): CardRunRecord | null {
+  return records.get(outTrackId.trim()) ?? null;
+}
+
+export function markCardRunStopRequested(outTrackId: string): void {
+  const record = records.get(outTrackId.trim());
+  if (record && !record.stopRequestedAt) {
+    record.stopRequestedAt = Date.now();
+  }
+}
+
+export function isCardRunStopRequested(outTrackId: string): boolean {
+  return Boolean(records.get(outTrackId.trim())?.stopRequestedAt);
+}
+
+export function removeCardRun(outTrackId: string): void {
+  records.delete(outTrackId.trim());
+  if (records.size === 0 && sweepTimer) {
+    clearInterval(sweepTimer);
+    sweepTimer = null;
+  }
+}
+
+export function clearCardRunRegistryForTest(): void {
+  records.clear();
+  if (sweepTimer) {
+    clearInterval(sweepTimer);
+    sweepTimer = null;
+  }
+}

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

@@ -0,0 +1,94 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { getAccessToken } from "../auth";
+import { finishStoppedAICard, hideCardStopButton } from "../card-service";
+import { dispatchDingTalkCardStopCommand } from "../command/card-stop-command";
+import type { DingTalkConfig, Logger } from "../types";
+import { AICardStatus } from "../types";
+import { markCardRunStopRequested, resolveCardRun } from "./card-run-registry";
+
+export interface StopCardRunResult {
+  ok: boolean;
+  status: string;
+  reason?: string;
+  /** Last streamed content before stop, so callback response can preserve it. */
+  lastContent?: string;
+}
+
+export async function stopCardRun(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  outTrackId: string;
+  config?: DingTalkConfig;
+  clickerUserId?: string;
+  log?: Logger;
+}): Promise<StopCardRunResult> {
+  const record = resolveCardRun(params.outTrackId);
+  if (!record) {
+    return { ok: false, status: "missing-run", reason: "No active card run registration found." };
+  }
+
+  if (record.stopRequestedAt || record.card?.state === AICardStatus.STOPPED) {
+    return { ok: true, status: "already-stopped", lastContent: record.card?.lastStreamedContent };
+  }
+
+  const lastContent = record.card?.lastStreamedContent;
+
+  markCardRunStopRequested(params.outTrackId);
+  record.controller?.stop();
+
+  // --- Phase 1: Abort agent execution via native /stop command ---
+  // Dispatch FIRST so that the current run is guaranteed to still be active
+  // on the session. If we finalized the card first, a new run could start on
+  // the same sessionKey in the async gap.
+  //
+  // Only abort when this card is actively dispatching (has a controller).
+  // Cards still queued behind session lock have no controller yet — the stop
+  // guard in inbound-handler will skip dispatch when the lock is acquired.
+  let nativeStopStatus: string | undefined;
+  if (record.controller) {
+    try {
+      await dispatchDingTalkCardStopCommand({
+        cfg: params.cfg,
+        accountId: params.accountId,
+        agentId: record.agentId,
+        targetSessionKey: record.sessionKey,
+        clickerUserId: params.clickerUserId ?? record.ownerUserId ?? "unknown",
+        log: params.log,
+      });
+      nativeStopStatus = "stopped";
+    } catch (error) {
+      params.log?.warn?.(
+        `[${params.accountId}] [DingTalk][CardStop] native stop dispatch failed: ${error instanceof Error ? error.message : String(error)}`,
+      );
+      nativeStopStatus = "stopped-dispatch-error";
+    }
+  }
+
+  // --- Phase 2: Finalize card via streaming API (isFinalize=true) ---
+  if (record.card) {
+    const stoppedContent = lastContent
+      ? `${lastContent}\n\n---\n*⏹️ 已停止*`
+      : "⏹️ 已停止";
+    try {
+      await finishStoppedAICard(record.card, stoppedContent, params.log);
+    } catch (error) {
+      params.log?.warn?.(
+        `[${params.accountId}] [DingTalk][CardStop] failed to finalize stopped card: ${error instanceof Error ? error.message : String(error)}`,
+      );
+    }
+  }
+
+  // --- 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

@@ -0,0 +1,20 @@
+/** Card variable value that shows the stop button. */
+export const STOP_ACTION_VISIBLE = "true";
+/** Card variable value that hides the stop button. */
+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";
+export const BUILTIN_DINGTALK_CARD_CONTENT_KEY = "content";
+
+export interface DingTalkCardTemplateContract {
+  templateId: string;
+  contentKey: 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,
+});
+

package/src/card-callback-service.ts

@@ -1,10 +1,18 @@
+import axios from "axios";
+import { getProxyBypassOption } from "./utils";
+
+const DINGTALK_API = "https://api.dingtalk.com";
+
 export interface CardCallbackAnalysis {
   summary: string;
   actionId?: string;
   feedbackTarget?: string;
   feedbackAckText?: string;
   userId?: string;
+  spaceId?: string;
   processQueryKey?: string;
+  outTrackId?: string;
+  cardInstanceId?: string;
 }
 
 function stringifyCandidate(value: unknown): string {
@@ -89,20 +97,58 @@ export function analyzeCardCallback(data: unknown): CardCallbackAnalysis {
   const actionId = extractCardActionId(data);
   const embeddedValue = asRecord(parseEmbeddedJson(record?.value));
   const embeddedContent = asRecord(parseEmbeddedJson(record?.content));
+  const embeddedCardPrivateData = asRecord(parseEmbeddedJson(record?.cardPrivateData));
+  const embeddedValuePrivateData = asRecord(parseEmbeddedJson(embeddedValue?.cardPrivateData));
+  const embeddedContentPrivateData = asRecord(parseEmbeddedJson(embeddedContent?.cardPrivateData));
+  const candidateRecords = [
+    record,
+    embeddedValue,
+    embeddedContent,
+    embeddedCardPrivateData,
+    embeddedValuePrivateData,
+    embeddedContentPrivateData,
+  ].filter(Boolean) as Array<Record<string, unknown>>;
+  const pickString = (...keys: string[]): string | undefined => {
+    for (const source of candidateRecords) {
+      for (const key of keys) {
+        const value = source[key];
+        if (typeof value === "string" && value.trim()) {
+          return value.trim();
+        }
+      }
+    }
+    return undefined;
+  };
   const processQueryKey =
-    (typeof record?.processQueryKey === "string" && record.processQueryKey.trim()) ||
-    (typeof embeddedValue?.processQueryKey === "string" && embeddedValue.processQueryKey.trim()) ||
-    (typeof embeddedContent?.processQueryKey === "string" && embeddedContent.processQueryKey.trim()) ||
-    undefined;
+    pickString("processQueryKey");
+  const outTrackId = pickString("outTrackId");
+  const cardInstanceId = pickString("cardInstanceId");
+  // For non-feedback paths, pickString is fine for spaceId/userId (broad search).
+  // For feedback paths, use precise extraction from record to avoid picking a
+  // same-named but different-valued spaceId from nested embedded objects.
+  const spaceId = pickString("spaceId");
+  const userId = pickString("userId");
 
   if (actionId !== "feedback_up" && actionId !== "feedback_down") {
-    return { summary, actionId, processQueryKey };
+    return {
+      summary,
+      actionId,
+      userId,
+      spaceId,
+      processQueryKey,
+      outTrackId,
+      cardInstanceId,
+    };
   }
 
+  // Feedback path: use precise extraction for spaceId/userId to avoid misrouting
+  // feedbackTarget when nested objects contain same-named fields with different values.
+  const preciseSpaceId =
+    (typeof record?.spaceId === "string" && record.spaceId.trim()) || spaceId;
+  const preciseUserId =
+    (typeof record?.userId === "string" && record.userId.trim()) || userId;
   const spaceType = typeof record?.spaceType === "string" ? record.spaceType.trim().toLowerCase() : "";
-  const spaceId = typeof record?.spaceId === "string" ? record.spaceId.trim() : "";
-  const userId = typeof record?.userId === "string" ? record.userId.trim() : "";
-  const feedbackTarget = spaceType === "im" ? userId : spaceId;
+  const feedbackTarget = spaceType === "im" ? preciseUserId : preciseSpaceId;
   const feedbackAckText =
     actionId === "feedback_up"
       ? "✅ 已收到你的点赞（反馈已记录）"
@@ -114,6 +160,42 @@ export function analyzeCardCallback(data: unknown): CardCallbackAnalysis {
     feedbackTarget: feedbackTarget || undefined,
     feedbackAckText,
     userId: userId || undefined,
+    spaceId: spaceId || undefined,
     processQueryKey,
+    outTrackId,
+    cardInstanceId,
   };
 }
+
+/**
+ * Update card variables via PUT /v1.0/card/instances.
+ * Echoes params back into cardParamMap so the template can use conditional
+ * rendering (e.g. hiding buttons when a param is set).
+ */
+export async function updateCardVariables(
+  outTrackId: string,
+  params: Record<string, unknown>,
+  token: string,
+  config?: { bypassProxyForSend?: boolean },
+): Promise<number> {
+  const stringMap: Record<string, string> = {};
+  for (const [k, v] of Object.entries(params)) {
+    stringMap[k] = typeof v === "string" ? v : JSON.stringify(v);
+  }
+  const resp = await axios.put(
+    `${DINGTALK_API}/v1.0/card/instances`,
+    {
+      outTrackId,
+      cardData: { cardParamMap: stringMap },
+      cardUpdateOptions: { updateCardDataByKey: true, updatePrivateDataByKey: true },
+    },
+    {
+      headers: {
+        "Content-Type": "application/json",
+        "x-acs-dingtalk-access-token": token,
+      },
+      ...getProxyBypassOption(config),
+    },
+  );
+  return resp.status;
+}

package/src/card-service.ts

@@ -3,6 +3,8 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import axios from "axios";
 import { getAccessToken } from "./auth";
+import { updateCardVariables } from "./card-callback-service";
+import { DINGTALK_CARD_TEMPLATE, STOP_ACTION_VISIBLE, STOP_ACTION_HIDDEN } from "./card/card-template";
 import { resolveRobotCode, stripTargetPrefix } from "./config";
 import { resolveOriginalPeerId } from "./peer-id-registry";
 import {
@@ -42,6 +44,26 @@ const CARD_CACHE_MAX_CONVERSATIONS = 500;
 const DYNAMIC_SUMMARY_EXTENSION = { dynamicSummary: "true" } as const;
 
 const aicardDegradeByAccount = new Map<string, { untilMs: number; reason: string }>();
+
+export async function hideCardStopButton(
+  outTrackId: string,
+  token: string,
+  config?: { bypassProxyForSend?: boolean },
+  retries = 2,
+): Promise<void> {
+  for (let attempt = 0; ; attempt++) {
+    try {
+      await updateCardVariables(outTrackId, { stop_action: STOP_ACTION_HIDDEN }, token, config);
+      return;
+    } catch (err) {
+      if (attempt >= retries) {
+        throw err;
+      }
+      await new Promise((r) => setTimeout(r, 500 * (attempt + 1)));
+    }
+  }
+}
+
 const inMemoryCardContentStore = new Map<
   string,
   {
@@ -198,6 +220,105 @@ function extractCardProcessQueryKey(payload: unknown): string | undefined {
   return undefined;
 }
 
+async function putAICardStreamingField(
+  card: AICardInstance,
+  key: string,
+  content: string,
+  finished: boolean,
+  log?: Logger,
+): Promise<void> {
+  const tokenAge = Date.now() - card.createdAt;
+  const tokenRefreshThreshold = 90 * 60 * 1000;
+  let tokenAlreadyRefreshed = false;
+
+  if (tokenAge > tokenRefreshThreshold && card.config) {
+    log?.debug?.("[DingTalk][AICard] Token age exceeds threshold, refreshing...");
+    try {
+      card.accessToken = await getAccessToken(card.config, log);
+      tokenAlreadyRefreshed = true;
+      log?.debug?.("[DingTalk][AICard] Token refreshed successfully");
+    } catch (err: any) {
+      log?.warn?.(`[DingTalk][AICard] Failed to refresh token: ${err.message}`);
+    }
+  }
+
+  const streamBody: AICardStreamingRequest = {
+    outTrackId: card.outTrackId || card.cardInstanceId,
+    guid: randomUUID(),
+    key,
+    content,
+    isFull: true,
+    isFinalize: finished,
+    isError: false,
+  };
+
+  log?.debug?.(
+    `[DingTalk][AICard] PUT /v1.0/card/streaming key=${key} contentLen=${content.length} isFull=true isFinalize=${finished} guid=${streamBody.guid} payload=${JSON.stringify(streamBody)}`,
+  );
+
+  const requestConfig = {
+    headers: {
+      "x-acs-dingtalk-access-token": card.accessToken,
+      "Content-Type": "application/json",
+    },
+    ...(card.config ? getProxyBypassOption(card.config) : {}),
+  };
+
+  try {
+    const streamResp = await axios.put(`${DINGTALK_API}/v1.0/card/streaming`, streamBody, requestConfig);
+    log?.debug?.(
+      `[DingTalk][AICard] Streaming response: status=${streamResp.status}, data=${JSON.stringify(streamResp.data)}`,
+    );
+    card.lastUpdated = Date.now();
+  } catch (err: any) {
+    if (err.response?.status === 401 && card.config && !tokenAlreadyRefreshed) {
+      log?.warn?.("[DingTalk][AICard] Received 401 error, attempting token refresh and retry...");
+      try {
+        card.accessToken = await getAccessToken(card.config, log);
+        const retryResp = await axios.put(`${DINGTALK_API}/v1.0/card/streaming`, streamBody, {
+          ...requestConfig,
+          headers: {
+            ...requestConfig.headers,
+            "x-acs-dingtalk-access-token": card.accessToken,
+          },
+        });
+        log?.debug?.(
+          `[DingTalk][AICard] Retry after token refresh succeeded: status=${retryResp.status}`,
+        );
+        card.lastUpdated = Date.now();
+        return;
+      } catch (retryErr: any) {
+        log?.error?.(`[DingTalk][AICard] Retry after token refresh failed: ${retryErr.message}`);
+        if (retryErr.response?.data !== undefined) {
+          log?.error?.(
+            formatDingTalkErrorPayloadLog(
+              "card.stream.retryAfterRefresh",
+              retryErr.response.data,
+              "[DingTalk][AICard]",
+            ),
+          );
+        }
+      }
+    }
+
+    if (card.accountId && shouldTriggerAICardDegrade(err)) {
+      activateAICardDegrade(
+        card.accountId,
+        `card.stream:${err?.response?.status || "unknown"}`,
+        card.config,
+        log,
+      );
+    }
+    log?.error?.(`[DingTalk][AICard] Streaming update failed: key=${key} ${err.message}`);
+    if (err.response?.data !== undefined) {
+      log?.error?.(
+        formatDingTalkErrorPayloadLog("card.stream", err.response.data, "[DingTalk][AICard]"),
+      );
+    }
+    throw err;
+  }
+}
+
 interface CreateAICardOptions {
   accountId?: string;
   storePath?: string;
@@ -372,7 +493,11 @@ function normalizeRecoveredState(state: string): AICardInstance["state"] {
 
 // Helper to identify card terminal states.
 export function isCardInTerminalState(state: string): boolean {
-  return state === AICardStatus.FINISHED || state === AICardStatus.FAILED;
+  return (
+    state === AICardStatus.FINISHED
+    || state === AICardStatus.STOPPED
+    || state === AICardStatus.FAILED
+  );
 }
 
 export function formatContentForCard(content: string | undefined, type: "thinking" | "tool"): string {
@@ -566,6 +691,7 @@ export async function createAICard(
     const shouldPersistPending =
       options.persistPending ?? Boolean(options.accountId && options.storePath);
     const token = await getAccessToken(config, log);
+    const template = DINGTALK_CARD_TEMPLATE;
     // Use randomUUID to avoid collisions across workers/restarts.
     const cardInstanceId = `card_${randomUUID()}`;
 
@@ -573,18 +699,17 @@ export async function createAICard(
 
     const isGroup = conversationId.startsWith("cid");
 
-    if (!config.cardTemplateId) {
-      throw new Error("DingTalk cardTemplateId is not configured.");
-    }
-
     // DingTalk createAndDeliver API payload.
-    const cardTemplateKey = config.cardTemplateKey || "content";
+    // Note: do NOT include template.statusKey here — the createAndDeliver API may
+    // reject unknown fields if the template variable is not yet provisioned.
+    // Status is set to "streaming" via the streaming API immediately after creation.
     const cardParamMap = {
       config: JSON.stringify({ autoLayout: true, enableForward: true }),
-      [cardTemplateKey]: "",
+      [template.contentKey]: "",
+      stop_action: STOP_ACTION_VISIBLE,
     };
     const createAndDeliverBody = {
-      cardTemplateId: config.cardTemplateId,
+      cardTemplateId: template.templateId,
       outTrackId: cardInstanceId,
       cardData: {
         cardParamMap,
@@ -674,6 +799,19 @@ export async function createAICard(
     }
 
     clearAICardDegrade(accountId, log);
+
+    // Kick the card into streaming mode immediately so the UI shows "输出中" and the
+    // stop button becomes visible. Without this, the card sits in "创建中" skeleton state
+    // until the first real content arrives — which may never happen for non-streaming replies.
+    // This sends an empty content stream (isFull=true, isFinalize=false) which transitions
+    // the card from PROCESSING to INPUTING on the DingTalk side.
+    try {
+      await putAICardStreamingField(aiCardInstance, template.contentKey, "", false, log);
+      aiCardInstance.state = AICardStatus.INPUTING;
+    } catch (kickErr: any) {
+      log?.debug?.(`[DingTalk][AICard] Non-critical: failed to kick card into streaming mode: ${kickErr.message}`);
+    }
+
     return aiCardInstance;
   } catch (err: any) {
     log?.error?.(`[DingTalk][AICard] Create failed: ${err.message}`);
@@ -704,55 +842,16 @@ export async function streamAICard(
   finished: boolean = false,
   log?: Logger,
 ): Promise<void> {
-  if (card.state === AICardStatus.FINISHED) {
+  if (isCardInTerminalState(card.state)) {
     log?.debug?.(
-      `[DingTalk][AICard] Skip stream update because card already finalized: outTrackId=${card.cardInstanceId}`,
+      `[DingTalk][AICard] Skip stream update because card already terminal: outTrackId=${card.cardInstanceId} state=${card.state}`,
     );
     return;
   }
-
-  // Refresh token defensively before DingTalk 2h token horizon.
-  const tokenAge = Date.now() - card.createdAt;
-  const tokenRefreshThreshold = 90 * 60 * 1000;
-
-  if (tokenAge > tokenRefreshThreshold && card.config) {
-    log?.debug?.("[DingTalk][AICard] Token age exceeds threshold, refreshing...");
-    try {
-      card.accessToken = await getAccessToken(card.config, log);
-      log?.debug?.("[DingTalk][AICard] Token refreshed successfully");
-    } catch (err: any) {
-      log?.warn?.(`[DingTalk][AICard] Failed to refresh token: ${err.message}`);
-    }
-  }
-
-  // Always use full replacement to make client rendering deterministic.
-  const streamBody: AICardStreamingRequest = {
-    outTrackId: card.outTrackId || card.cardInstanceId,
-    guid: randomUUID(),
-    key: card.config?.cardTemplateKey || "content",
-    content: content,
-    isFull: true,
-    isFinalize: finished,
-    isError: false,
-  };
-
-  log?.debug?.(
-    `[DingTalk][AICard] PUT /v1.0/card/streaming contentLen=${content.length} isFull=true isFinalize=${finished} guid=${streamBody.guid} payload=${JSON.stringify(streamBody)}`,
-  );
+  const template = DINGTALK_CARD_TEMPLATE;
 
   try {
-    const streamResp = await axios.put(`${DINGTALK_API}/v1.0/card/streaming`, streamBody, {
-      headers: {
-        "x-acs-dingtalk-access-token": card.accessToken,
-        "Content-Type": "application/json",
-      },
-      ...(card.config ? getProxyBypassOption(card.config) : {}),
-    });
-    log?.debug?.(
-      `[DingTalk][AICard] Streaming response: status=${streamResp.status}, data=${JSON.stringify(streamResp.data)}`,
-    );
-
-    card.lastUpdated = Date.now();
+    await putAICardStreamingField(card, template.contentKey, content, finished, log);
     card.lastStreamedContent = content;
     if (finished) {
       card.state = AICardStatus.FINISHED;
@@ -761,85 +860,14 @@ export async function streamAICard(
       card.state = AICardStatus.INPUTING;
     }
   } catch (err: any) {
-    // 500 unknownError usually means cardTemplateKey mismatch with template variable names.
-    if (err.response?.status === 500 && err.response?.data?.code === "unknownError") {
-      const usedKey = streamBody.key;
-      const cardTemplateId = card.config?.cardTemplateId || "(unknown)";
-      const errorMsg =
-        `⚠️ **[DingTalk] AI Card 串流更新失败 (500 unknownError)**\n\n` +
-        `这通常是因为 \`cardTemplateKey\` (当前值: \`${usedKey}\`) 与钉钉卡片模板 \`${cardTemplateId}\` 中定义的正文变量名不匹配。\n\n` +
-        `**建议操作**：\n` +
-        `1. 前往钉钉开发者后台检查该模板的“变量管理”\n` +
-        `2. 确保配置中的 \`cardTemplateKey\` 与模板中用于显示内容的字段变量名完全一致\n\n` +
-        `*注意：当前及后续消息将自动转为 Markdown 发送，直到问题修复。*\n` +
-        `*参考文档: https://github.com/soimy/openclaw-channel-dingtalk/blob/main/README.md#3-%E5%BB%BA%E7%AB%8B%E5%8D%A1%E7%89%87%E6%A8%A1%E6%9D%BF%E5%8F%AF%E9%80%89`;
-
-      log?.error?.(
-        `[DingTalk][AICard] Streaming failed with 500 unknownError. Key: ${usedKey}, Template: ${cardTemplateId}. ` +
-          `Verify that "cardTemplateKey" matches the content field variable name in your card template.`,
-      );
-
-      card.state = AICardStatus.FAILED;
-      card.lastUpdated = Date.now();
-      removePendingCard(card, log);
-      await sendTemplateMismatchNotification(card, errorMsg, log);
-      throw err;
-    }
-
-    // Retry once on 401 with refreshed token.
-    if (err.response?.status === 401 && card.config) {
-      log?.warn?.("[DingTalk][AICard] Received 401 error, attempting token refresh and retry...");
-      try {
-        card.accessToken = await getAccessToken(card.config, log);
-        const retryResp = await axios.put(`${DINGTALK_API}/v1.0/card/streaming`, streamBody, {
-          headers: {
-            "x-acs-dingtalk-access-token": card.accessToken,
-            "Content-Type": "application/json",
-          },
-          ...(card.config ? getProxyBypassOption(card.config) : {}),
-        });
-        log?.debug?.(
-          `[DingTalk][AICard] Retry after token refresh succeeded: status=${retryResp.status}`,
-        );
-        card.lastUpdated = Date.now();
-        card.lastStreamedContent = content;
-        if (finished) {
-          card.state = AICardStatus.FINISHED;
-          removePendingCard(card, log);
-        } else if (card.state === AICardStatus.PROCESSING) {
-          card.state = AICardStatus.INPUTING;
-        }
-        return;
-      } catch (retryErr: any) {
-        log?.error?.(`[DingTalk][AICard] Retry after token refresh failed: ${retryErr.message}`);
-        if (retryErr.response?.data !== undefined) {
-          log?.error?.(
-            formatDingTalkErrorPayloadLog(
-              "card.stream.retryAfterRefresh",
-              retryErr.response.data,
-              "[DingTalk][AICard]",
-            ),
-          );
-        }
-      }
-    }
-
     card.state = AICardStatus.FAILED;
     card.lastUpdated = Date.now();
     removePendingCard(card, log);
-    if (card.accountId && shouldTriggerAICardDegrade(err)) {
-      activateAICardDegrade(
-        card.accountId,
-        `card.stream:${err?.response?.status || "unknown"}`,
-        card.config,
-        log,
-      );
-    }
-    log?.error?.(`[DingTalk][AICard] Streaming update failed: ${err.message}`);
-    if (err.response?.data !== undefined) {
-      log?.error?.(
-        formatDingTalkErrorPayloadLog("card.stream", err.response.data, "[DingTalk][AICard]"),
-      );
+    if (err.response?.status === 500 && err.response?.data?.code === "unknownError") {
+      const errorMsg =
+        "⚠️ **[DingTalk] AI Card 串流更新失败 (500 unknownError)**\n\n"
+        + "这通常表示当前内置模板契约与钉钉侧模板字段不一致，当前及后续消息将自动回退为 Markdown 发送。";
+      await sendTemplateMismatchNotification(card, errorMsg, log);
     }
     throw err;
   }
@@ -853,6 +881,15 @@ export async function finishAICard(
 ): Promise<void> {
   log?.debug?.(`[DingTalk][AICard] Starting finish, final content length=${content.length}`);
   await streamAICard(card, content, true, log);
+  // Hide stop button on normal completion (symmetric with card-stop-handler).
+  if (card.outTrackId && card.config) {
+    try {
+      const token = await getAccessToken(card.config, log);
+      await hideCardStopButton(card.outTrackId, token, card.config);
+    } catch (err: any) {
+      log?.debug?.(`[DingTalk][AICard] Non-critical: failed to hide stop button on finish: ${err.message}`);
+    }
+  }
   if (card.conversationId && content.trim() && card.accountId && card.processQueryKey) {
     const primaryConversationId = card.contextConversationId || card.conversationId;
     cacheCardContentByProcessQueryKey(
@@ -867,6 +904,30 @@ export async function finishAICard(
   }
 }
 
+export async function finishStoppedAICard(
+  card: AICardInstance,
+  content: string,
+  log?: Logger,
+): Promise<void> {
+  if (isCardInTerminalState(card.state)) {
+    log?.debug?.(
+      `[DingTalk][AICard] finishStoppedAICard skipped — already terminal: ${card.state}`,
+    );
+    return;
+  }
+  const template = DINGTALK_CARD_TEMPLATE;
+  try {
+    await putAICardStreamingField(card, template.contentKey, content, true, log);
+  } finally {
+    // Ensure local state is consistent even when the streaming API call fails.
+    // The card is logically stopped regardless of whether DingTalk acknowledged it.
+    card.lastStreamedContent = content;
+    card.state = AICardStatus.STOPPED;
+    card.lastUpdated = Date.now();
+    removePendingCard(card, log);
+  }
+}
+
 function cacheCardContentByProcessQueryKey(
   accountId: string,
   conversationId: string,

package/src/channel.ts

@@ -7,6 +7,7 @@ import { readStringParam } from "openclaw/plugin-sdk/param-readers";
 import { extractToolSend } from "openclaw/plugin-sdk/tool-send";
 import { getAccessToken } from "./auth";
 import { analyzeCardCallback } from "./card-callback-service";
+import { handleCardAction } from "./card/card-action-handler";
 import {
   createAICard,
   streamAICard,
@@ -837,6 +838,18 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
                 );
               }
             }
+            const actionResult = await handleCardAction({
+              analysis,
+              cfg,
+              accountId: account.accountId,
+              config,
+              log: ctx.log,
+            });
+            if (!actionResult.handled && analysis.actionId && analysis.actionId !== "feedback_up" && analysis.actionId !== "feedback_down") {
+              ctx.log?.debug?.(
+                `[${account.accountId}] [DingTalk][CardCallback] Unhandled actionId=${analysis.actionId}`,
+              );
+            }
           } catch (error: any) {
             ctx.log?.error?.(
               `[${account.accountId}] [DingTalk][CardCallback] Failed to parse callback: ${error.message}`,

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

@@ -0,0 +1,96 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk";
+import { getDingTalkRuntime } from "../runtime";
+import type { Logger } from "../types";
+
+/**
+ * Local implementation of the same logic as
+ * `resolveNativeCommandSessionTargets` from `openclaw/plugin-sdk/command-auth`.
+ *
+ * Inlined because the CI openclaw package does not yet export that sub-path.
+ * Replace with a direct import once the upstream package is updated.
+ */
+function resolveNativeCommandSessionTargets(params: {
+  agentId: string;
+  sessionPrefix: string;
+  userId: string;
+  targetSessionKey: string;
+}): { sessionKey: string; commandTargetSessionKey: string } {
+  return {
+    sessionKey: `agent:${params.agentId}:${params.sessionPrefix}:${params.userId}`,
+    commandTargetSessionKey: params.targetSessionKey,
+  };
+}
+
+/**
+ * Dispatch a native targeted `/stop` command through the OpenClaw SDK,
+ * replacing the previous self-built Gateway WebSocket `chat.abort` approach.
+ *
+ * Uses the same `resolveNativeCommandSessionTargets` + `CommandSource: "native"`
+ * model as Telegram / Discord / Slack slash commands, producing:
+ *   - A dedicated command SessionKey (`agent:<agentId>:dingtalk:card-stop:<userId>`)
+ *   - A CommandTargetSessionKey pointing at the real conversation session
+ *
+ * Inside the SDK, `dispatch-from-config` → `tryFastAbortFromMessage` picks up
+ * the `/stop` body, resolves the target session via `CommandTargetSessionKey`,
+ * and executes `abortEmbeddedPiRun` + `clearSessionQueues`.
+ *
+ * Accesses SDK functions via `getDingTalkRuntime().channel.reply` — the same
+ * pattern used by `inbound-handler.ts` — to avoid direct sub-path imports
+ * that may not be available in the CI openclaw package version.
+ */
+export async function dispatchDingTalkCardStopCommand(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  agentId: string;
+  targetSessionKey: string;
+  clickerUserId: string;
+  log?: Logger;
+}): Promise<{ ok: boolean }> {
+  const rt = getDingTalkRuntime();
+
+  const { sessionKey: commandSessionKey, commandTargetSessionKey } =
+    resolveNativeCommandSessionTargets({
+      agentId: params.agentId,
+      sessionPrefix: "dingtalk:card-stop",
+      userId: params.clickerUserId,
+      targetSessionKey: params.targetSessionKey,
+    });
+
+  const ctx = rt.channel.reply.finalizeInboundContext({
+    Body: "/stop",
+    RawBody: "/stop",
+    CommandBody: "/stop",
+    SessionKey: commandSessionKey,
+    CommandTargetSessionKey: commandTargetSessionKey,
+    CommandSource: "native" as const,
+    CommandAuthorized: true,
+    AccountId: params.accountId,
+    Provider: "dingtalk",
+    Surface: "dingtalk",
+    // "direct" because the synthetic /stop body contains no @mentions to strip.
+    // The actual chat type of the target session is irrelevant for abort routing.
+    ChatType: "direct",
+    From: `dingtalk:card-stop:${params.clickerUserId}`,
+    To: `card-stop:${params.clickerUserId}`,
+    SenderId: params.clickerUserId,
+    OriginatingChannel: "dingtalk",
+  });
+
+  // DispatchInboundResult = { queuedFinal, counts } — the return value does
+  // not expose whether tryFastAbortFromMessage took the fast-abort path.
+  // Treat successful dispatch as best-effort abort, consistent with the
+  // previous gateway chat.abort approach.
+  await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+    ctx,
+    cfg: params.cfg,
+    dispatcherOptions: {
+      responsePrefix: "",
+      deliver: async () => {
+        // SDK abort confirmation text is swallowed here; the card
+        // finalize path handles stopped content independently.
+      },
+    },
+  });
+
+  return { ok: true };
+}

package/src/inbound-handler.ts

@@ -8,6 +8,12 @@ import { extractAttachmentText } from "./attachment-text-extractor";
 import { getAccessToken } from "./auth";
 import { createAICard, finishAICard, isCardInTerminalState } from "./card-service";
 import { resolveAckReactionSetting, resolveGroupConfig, resolveRobotCode } from "./config";
+import { AICardStatus } from "./types";
+import {
+  isCardRunStopRequested,
+  registerCardRun,
+  removeCardRun,
+} from "./card/card-run-registry";
 import {
   applyManualTargetLearningRule,
   applyManualTargetsLearningRule,
@@ -83,7 +89,6 @@ import {
   upsertObservedGroupTarget,
   upsertObservedUserTarget,
 } from "./targeting/target-directory-store";
-import { AICardStatus } from "./types";
 import type { DingTalkConfig, HandleDingTalkMessageParams, MediaFile } from "./types";
 import { formatDingTalkErrorPayloadLog, getErrorMessage, getErrorResponseData, maskSensitiveData } from "./utils";
 import { isAbortRequestText } from "openclaw/plugin-sdk/reply-runtime";
@@ -1046,7 +1051,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   // Card creation runs BEFORE media download so the user sees immediate visual
   // feedback while large files are still being downloaded.
   let useCardMode = dingtalkConfig.messageType === "card";
-  let currentAICard = undefined;
+  let currentAICard: import("./types").AICardInstance | undefined;
 
   if (useCardMode) {
     try {
@@ -1060,6 +1065,15 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       });
       if (aiCard) {
         currentAICard = aiCard;
+        if (aiCard.outTrackId) {
+          registerCardRun(aiCard.outTrackId, {
+            accountId,
+            sessionKey: route.sessionKey,
+            agentId: route.agentId,
+            ownerUserId: senderId,
+            card: aiCard,
+          });
+        }
       } else {
         useCardMode = false;
         log?.warn?.(
@@ -1798,6 +1812,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
   // causes empty replies for all but the first caller.
   // Each sub-agent call acquires its own lock since sub-agent sessions have
   // different session keys (different agentId), so no deadlock risk.
+  const currentOutTrackId = currentAICard?.outTrackId;
   const shouldTrackDynamicAckReaction =
     (normalizedAckReaction === "emoji" || normalizedAckReaction === "kaomoji")
     && shouldAttachAckReaction;
@@ -1826,6 +1841,19 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
     if (!ackReactionAttached && shouldAttachAckReaction) {
       log?.debug?.("[DingTalk] Native ack reaction unavailable; skipping fallback.");
     }
+    const isCurrentCardStopRequested = () =>
+      Boolean(
+        currentAICard
+        && (
+          currentAICard.state === AICardStatus.STOPPED
+          || (currentOutTrackId && isCardRunStopRequested(currentOutTrackId))
+        ),
+      );
+
+    if (isCurrentCardStopRequested()) {
+      log?.info?.("[DingTalk][CardStop] Skip dispatch because card was already stopped before session lock was acquired");
+      return;
+    }
 
     // ---- Create reply strategy (card or markdown) ----
     const strategy = createReplyStrategy({
@@ -1842,6 +1870,7 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
       log,
       replyQuotedRef,
       deliverMedia: deliverMediaAttachments,
+      isStopRequested: isCurrentCardStopRequested,
     });
 
     try {
@@ -1851,6 +1880,10 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
         dispatcherOptions: {
           responsePrefix: subAgentOptions?.responsePrefix || "",
           deliver: async (payload: ReplyStreamPayload, info?: ReplyChunkInfo) => {
+            if (isCurrentCardStopRequested()) {
+              log?.debug?.("[DingTalk][CardStop] Ignoring reply delivery because stop was already requested");
+              return;
+            }
             try {
               const mediaUrls = extractMediaUrls(payload);
               await strategy.deliver({
@@ -1878,6 +1911,13 @@ export async function handleDingTalkMessage(params: HandleDingTalkMessageParams)
 
     await strategy.finalize();
   } finally {
+    // Only remove the registry entry if no stop was requested. When a stop is
+    // in progress, card-stop-handler may still be running async operations
+    // (finalize card, hide button, gateway abort) that read the record.
+    // In that case, let the 30-minute TTL sweep handle cleanup.
+    if (currentOutTrackId && !isCardRunStopRequested(currentOutTrackId)) {
+      removeCardRun(currentOutTrackId);
+    }
     await waitForDynamicAckDispose({
       dispose: () => dynamicAckReactionController.dispose(MIN_THINKING_REACTION_VISIBLE_MS),
       log,

package/src/onboarding.ts

@@ -126,8 +126,6 @@ function applyAccountConfig(params: {
       ? { mediaUrlAllowlist: input.mediaUrlAllowlist }
       : {}),
     ...(input.messageType ? { messageType: input.messageType } : {}),
-    ...(input.cardTemplateId ? { cardTemplateId: input.cardTemplateId } : {}),
-    ...(input.cardTemplateKey ? { cardTemplateKey: input.cardTemplateKey } : {}),
     ...(typeof input.maxReconnectCycles === "number"
       ? { maxReconnectCycles: input.maxReconnectCycles }
       : {}),
@@ -234,41 +232,17 @@ async function configureDingTalkAccount(params: {
     initialValue: resolved.messageType === "card",
   });
 
-  let cardTemplateId: string | undefined;
-  let cardTemplateKey: string | undefined;
   let messageType: "markdown" | "card" = "markdown";
 
   if (wantsCardMode) {
     await prompter.note(
       [
-        "Create an AI card template in DingTalk Developer Console:",
-        "https://open-dev.dingtalk.com/fe/card",
-        "1. Go to 'My Templates' > 'Create Template'",
-        "2. Select 'AI Card' scenario",
-        "3. Design your card and publish",
-        "4. Copy the Template ID (e.g., xxx.schema)",
+        "AI interactive card mode now uses the built-in DingTalk template contract.",
+        "No manual Template ID or content field configuration is required.",
+        "Legacy cardTemplateId/cardTemplateKey config is deprecated and ignored.",
       ].join("\n"),
-      "Card Template Setup",
+      "Built-in AI Card Template",
     );
-
-    cardTemplateId =
-      String(
-        await prompter.text({
-          message: "Card Template ID",
-          placeholder: "xxxxx-xxxxx-xxxxx.schema",
-          initialValue: resolved.cardTemplateId ?? undefined,
-        }),
-      ).trim() || undefined;
-
-    cardTemplateKey =
-      String(
-        await prompter.text({
-          message: "Card Template Key (content field name)",
-          placeholder: "content",
-          initialValue: resolved.cardTemplateKey ?? "content",
-        }),
-      ).trim() || "content";
-
     messageType = "card";
   }
 
@@ -436,8 +410,6 @@ async function configureDingTalkAccount(params: {
       displayNameResolution: displayNameResolutionValue as "disabled" | "all",
       mediaUrlAllowlist,
       messageType,
-      cardTemplateId,
-      cardTemplateKey,
       maxReconnectCycles,
       mediaMaxMb,
       journalTTLDays,

package/src/reply-strategy-card.ts

@@ -11,6 +11,7 @@ import {
   isCardInTerminalState,
 } from "./card-service";
 import { createCardDraftController } from "./card-draft-controller";
+import { attachCardRunController } from "./card/card-run-registry";
 import type { DeliverPayload, ReplyOptions, ReplyStrategy, ReplyStrategyContext } from "./reply-strategy";
 import { sendBySession, sendMessage } from "./send-service";
 import type { AICardInstance } from "./types";
@@ -20,11 +21,14 @@ import { formatDingTalkErrorPayloadLog } from "./utils";
 const FILE_ONLY_FALLBACK_ANSWER = "附件已发送，请查收。";
 
 export function createCardReplyStrategy(
-  ctx: ReplyStrategyContext & { card: AICardInstance },
+  ctx: ReplyStrategyContext & { card: AICardInstance; isStopRequested?: () => boolean },
 ): ReplyStrategy {
-  const { card, config, log } = ctx;
+  const { card, config, log, isStopRequested } = ctx;
 
   const controller = createCardDraftController({ card, log });
+  if (card.outTrackId) {
+    attachCardRunController(card.outTrackId, controller);
+  }
   let finalTextForFallback: string | undefined;
   let sawFinalDelivery = false;
 
@@ -44,19 +48,22 @@ export function createCardReplyStrategy(
         disableBlockStreaming: true,
 
         onAssistantMessageStart: async () => {
+          if (isStopRequested?.()) {
+            return;
+          }
           await controller.notifyNewAssistantTurn();
         },
 
         onPartialReply: config.cardRealTimeStream
           ? async (payload) => {
-              if (payload.text) {
+              if (payload.text && !isStopRequested?.()) {
                 await controller.updateAnswer(payload.text);
               }
             }
           : undefined,
 
         onReasoningStream: async (payload) => {
-          if (payload.text) {
+          if (payload.text && !isStopRequested?.()) {
             await controller.updateThinking(payload.text);
           }
         },
@@ -122,11 +129,21 @@ export function createCardReplyStrategy(
         `lastContent="${(controller.getLastContent() ?? "").slice(0, 80)}"`,
       );
 
+      if (isStopRequested?.()) {
+        log?.info?.("[DingTalk][Finalize] Skipping — card stop was requested");
+        return;
+      }
+
       if (card.state === AICardStatus.FINISHED) {
         log?.info?.("[DingTalk][Finalize] Skipping — card already FINISHED");
         return;
       }
 
+      if (card.state === AICardStatus.STOPPED) {
+        log?.info?.("[DingTalk][Finalize] Skipping — card already STOPPED");
+        return;
+      }
+
       // Card failed -> markdown fallback (bypass sendMessage to avoid duplicate card).
       if (card.state === AICardStatus.FAILED || controller.isFailed()) {
         const fallbackText = getRenderedTimeline({ preferFinalAnswer: true })

package/src/reply-strategy.ts

@@ -55,6 +55,7 @@ export interface ReplyStrategyContext {
   log?: Logger;
   replyQuotedRef?: QuotedRef;
   deliverMedia: (urls: string[]) => Promise<void>;
+  isStopRequested?: () => boolean;
 }
 
 // ---- Factory -----------------------------------------------------

package/src/send-service.ts

@@ -225,7 +225,7 @@ export async function sendProactiveTextOrMarkdown(
 
   // In card mode, use card API to avoid oToMessages/batchSend permission requirement.
   const messageType = config.messageType || "markdown";
-  if (messageType === "card" && config.cardTemplateId && !options.forceMarkdown) {
+  if (messageType === "card" && !options.forceMarkdown) {
     log?.debug?.(
       `[DingTalk] Using card API for proactive message to user ${resolvedTarget}${proactiveRiskTag}`,
     );
@@ -582,20 +582,18 @@ export async function sendMessage(
           return { ok: true };
         }
 
-        if (config.cardTemplateId) {
-          const proactiveResult = await sendProactiveCardText(config, conversationId, text, log);
-          if (!proactiveResult.ok) {
-            return { ok: false, error: proactiveResult.error || "Card send failed" };
-          }
-          return {
-            ok: true,
-            tracking: {
-              processQueryKey: proactiveResult.processQueryKey,
-              outTrackId: proactiveResult.outTrackId,
-              cardInstanceId: proactiveResult.cardInstanceId,
-            },
-          };
+        const proactiveResult = await sendProactiveCardText(config, conversationId, text, log);
+        if (!proactiveResult.ok) {
+          return { ok: false, error: proactiveResult.error || "Card send failed" };
         }
+        return {
+          ok: true,
+          tracking: {
+            processQueryKey: proactiveResult.processQueryKey,
+            outTrackId: proactiveResult.outTrackId,
+            cardInstanceId: proactiveResult.cardInstanceId,
+          },
+        };
       }
     }
 

package/src/types.ts

@@ -44,7 +44,9 @@ export interface DingTalkConfig extends OpenClawConfig {
   ackReaction?: AckReactionConfigValue;
   debug?: boolean;
   messageType?: "markdown" | "card";
+  /** @deprecated 已固定使用内置模板契约 */
   cardTemplateId?: string;
+  /** @deprecated 已固定使用内置模板契约 */
   cardTemplateKey?: string;
   groups?: Record<string, { systemPrompt?: string; requireMention?: boolean; groupAllowFrom?: string[] }>;
   accounts?: Record<string, DingTalkConfig>;
@@ -103,7 +105,9 @@ export interface DingTalkChannelConfig {
   ackReaction?: AckReactionConfigValue;
   debug?: boolean;
   messageType?: "markdown" | "card";
+  /** @deprecated 已固定使用内置模板契约 */
   cardTemplateId?: string;
+  /** @deprecated 已固定使用内置模板契约 */
   cardTemplateKey?: string;
   groups?: Record<string, { systemPrompt?: string; requireMention?: boolean; groupAllowFrom?: string[] }>;
   accounts?: Record<string, DingTalkConfig>;
@@ -618,6 +622,7 @@ export const AICardStatus = {
   PROCESSING: "1",
   INPUTING: "2",
   FINISHED: "3",
+  STOPPED: "4",
   FAILED: "5",
 } as const;
 
@@ -639,7 +644,7 @@ export interface AICardInstance {
   storePath?: string;
   createdAt: number;
   lastUpdated: number;
-  state: AICardState; // Current card state: PROCESSING, INPUTING, FINISHED, FAILED
+  state: AICardState; // Current card state: PROCESSING, INPUTING, FINISHED, STOPPED, FAILED
   config?: DingTalkConfig; // Store config reference for token refresh
   lastStreamedContent?: string;
   outTrackId?: string;