@soimy/dingtalk 3.4.2 → 3.5.1

package/src/card-service.ts

@@ -3,13 +3,17 @@ import * as fs from "node:fs";
 import * as path from "node:path";
 import axios from "axios";
 import { getAccessToken } from "./auth";
-import { stripTargetPrefix } from "./config";
+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 {
   createSyntheticOutboundMsgId,
   clearMessageContextCacheForTest,
   DEFAULT_CARD_CONTENT_TTL_MS,
   DEFAULT_CREATED_AT_MATCH_WINDOW_MS,
+  DEFAULT_OUTBOUND_SENDER,
+  inferConversationChatType,
   resolveByCreatedAtWindow,
   upsertOutboundMessageContext,
 } from "./message-context-store";
@@ -40,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,
   {
@@ -196,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;
@@ -370,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 {
@@ -409,7 +536,7 @@ async function sendTemplateMismatchNotification(
 
     // Direct markdown fallback notification to user/group, without re-entering sendMessage card flow.
     const payload: Record<string, unknown> = {
-      robotCode: config.robotCode || config.clientId,
+      robotCode: resolveRobotCode(config),
       msgKey: "sampleMarkdown",
       msgParam: JSON.stringify({ title: "OpenClaw 提醒", text }),
     };
@@ -564,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()}`;
 
@@ -571,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,
@@ -596,26 +723,19 @@ export async function createAICard(
       userIdType: 1,
       imGroupOpenDeliverModel: isGroup
         ? {
-            robotCode: config.robotCode || config.clientId,
+            robotCode: resolveRobotCode(config),
             extension: DYNAMIC_SUMMARY_EXTENSION,
           }
         : undefined,
       imRobotOpenDeliverModel: !isGroup
         ? {
             spaceType: "IM_ROBOT",
-            robotCode: config.robotCode || config.clientId,
+            robotCode: resolveRobotCode(config),
             extension: DYNAMIC_SUMMARY_EXTENSION,
           }
         : undefined,
     };
 
-    if (isGroup && !config.robotCode) {
-      log?.warn?.(
-        "[DingTalk][AICard] robotCode not configured, using clientId as fallback. " +
-          "For best compatibility, set robotCode explicitly in config.",
-      );
-    }
-
     log?.debug?.(
       `[DingTalk][AICard] POST /v1.0/card/instances/createAndDeliver body=${JSON.stringify(createAndDeliverBody)}`,
     );
@@ -679,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}`);
@@ -709,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;
@@ -766,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;
   }
@@ -858,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(
@@ -872,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,
@@ -895,6 +951,8 @@ function cacheCardContentByProcessQueryKey(
     createdAt: Date.now(),
     text: content,
     messageType: "card",
+    ...DEFAULT_OUTBOUND_SENDER,
+    chatType: inferConversationChatType(conversationId),
     ttlMs: DEFAULT_CARD_CONTENT_TTL_MS,
     topic: null,
     quotedRef,
@@ -932,6 +990,8 @@ export function cacheCardContent(
     createdAt,
     text: content,
     messageType: "card",
+    ...DEFAULT_OUTBOUND_SENDER,
+    chatType: inferConversationChatType(conversationId),
     ttlMs: DEFAULT_CARD_CONTENT_TTL_MS,
     topic: null,
   });

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,
@@ -20,14 +21,15 @@ import {
   mergeAccountWithDefaults,
   resolveGroupConfig,
   resolveRelativePath,
+  resolveRobotCode,
   stripTargetPrefix,
 } from "./config";
 import { DingTalkConfigSchema } from "./config-schema.js";
 import { ConnectionManager } from "./connection-manager";
 import { isMessageProcessed, markMessageProcessed } from "./dedup";
 import {
-  isFeedbackLearningAutoApplyEnabled,
-  isFeedbackLearningEnabled,
+  isLearningAutoApplyEnabled,
+  isLearningEnabled,
   recordExplicitFeedbackLearning,
 } from "./feedback-learning-service";
 import { handleDingTalkMessage } from "./inbound-handler";
@@ -708,7 +710,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
           try {
             const data = JSON.parse(res.data) as DingTalkInboundMessage;
 
-            const robotKey = config.robotCode || config.clientId || account.accountId;
+            const robotKey = resolveRobotCode(config) || account.accountId;
             const msgId = data.msgId || messageId;
             const dedupKey = msgId ? `${robotKey}:${msgId}` : undefined;
 
@@ -807,15 +809,15 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
 
             if (analysis.feedbackTarget && analysis.feedbackAckText) {
               recordExplicitFeedbackLearning({
-                enabled: isFeedbackLearningEnabled(config),
-                autoApply: isFeedbackLearningAutoApplyEnabled(config),
+                enabled: isLearningEnabled(config),
+                autoApply: isLearningAutoApplyEnabled(config),
                 storePath: accountStorePath,
                 accountId: account.accountId,
                 targetId: analysis.feedbackTarget,
                 feedbackType: analysis.actionId === "feedback_up" ? "feedback_up" : "feedback_down",
                 userId: analysis.userId,
                 processQueryKey: analysis.processQueryKey,
-                noteTtlMs: config.learningNoteTtlMs ?? config.feedbackLearningNoteTtlMs,
+                noteTtlMs: config.learningNoteTtlMs,
               });
               try {
                 await sendProactiveTextOrMarkdown(
@@ -836,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}`,
@@ -984,7 +998,7 @@ export const dingtalkPlugin: DingTalkChannelPlugin = {
             // Clear stale in-flight locks for this account on disconnect.
             // DingTalk will redeliver unacknowledged messages on reconnect; without
             // this cleanup the redelivered messages would be silently skipped forever.
-            const robotKey = config.robotCode || config.clientId || account.accountId;
+            const robotKey = resolveRobotCode(config) || account.accountId;
             let cleared = 0;
             for (const key of processingDedupKeys.keys()) {
               if (key.startsWith(`${robotKey}:`)) {

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/config-schema.ts

@@ -20,15 +20,6 @@ const DingTalkAccountConfigShape = {
   /** DingTalk App Secret (Client Secret) - required for authentication */
   clientSecret: z.string().optional(),
 
-  /** DingTalk Robot Code for media download */
-  robotCode: z.string().optional(),
-
-  /** DingTalk Corporation ID */
-  corpId: z.string().optional(),
-
-  /** DingTalk Application ID (Agent ID) */
-  agentId: z.union([z.string(), z.number()]).optional(),
-
   /** Direct message policy: open, pairing, or allowlist */
   dmPolicy: z.enum(["open", "pairing", "allowlist"]).optional().default("open"),
 
@@ -134,15 +125,6 @@ const DingTalkAccountConfigShape = {
   /** Session learning note TTL in milliseconds (default: 6 hours) */
   learningNoteTtlMs: z.number().int().min(60_000).optional(),
 
-  /** @deprecated Use learningEnabled */
-  feedbackLearningEnabled: z.boolean().optional(),
-
-  /** @deprecated Use learningAutoApply */
-  feedbackLearningAutoApply: z.boolean().optional(),
-
-  /** @deprecated Use learningNoteTtlMs */
-  feedbackLearningNoteTtlMs: z.number().int().min(60_000).optional(),
-
   /** Whether to convert markdown tables to plain text for better rendering on some clients (default: true) */
   convertMarkdownTables: z.boolean().optional().default(true),