@yaoyuanchao/dingtalk 1.6.1 → 1.7.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaoyuanchao/dingtalk",
-  "version": "1.6.1",
+  "version": "1.7.1",
   "type": "module",
   "description": "DingTalk channel plugin for ClawdBot/OpenClaw with Stream Mode support",
   "license": "MIT",

package/src/accounts.ts

@@ -1,56 +1,141 @@
 import type { ResolvedDingTalkAccount, DingTalkChannelConfig } from "./types.js";
-import { validateDingTalkConfig, type DingTalkConfig } from "./config-schema.js";
+import { validateDingTalkAccountConfig, type DingTalkAccountConfig } from "./config-schema.js";
 
 const DEFAULT_ACCOUNT_ID = "default";
 const ENV_CLIENT_ID = "DINGTALK_CLIENT_ID";
 const ENV_CLIENT_SECRET = "DINGTALK_CLIENT_SECRET";
 const ENV_ROBOT_CODE = "DINGTALK_ROBOT_CODE";
 
+/**
+ * List all configured account IDs.
+ * When `accounts` map exists, returns those keys. Otherwise returns ['default'].
+ */
 export function listDingTalkAccountIds(cfg: any): string[] {
   const channel = cfg?.channels?.dingtalk as DingTalkChannelConfig | undefined;
-  if (!channel) return [DEFAULT_ACCOUNT_ID];
-  return [DEFAULT_ACCOUNT_ID];
+  if (!channel) return [];
+
+  // Multi-account mode
+  if (channel.accounts && typeof channel.accounts === 'object') {
+    const ids = Object.keys(channel.accounts).filter(id => {
+      const acct = channel.accounts![id];
+      return acct && acct.enabled !== false;
+    });
+    if (ids.length > 0) return ids;
+  }
+
+  // Single-account fallback
+  if (channel.clientId) return [DEFAULT_ACCOUNT_ID];
+  return [];
 }
 
+/**
+ * Resolve the default account ID.
+ */
 export function resolveDefaultDingTalkAccountId(cfg: any): string {
+  const channel = cfg?.channels?.dingtalk as DingTalkChannelConfig | undefined;
+  if (!channel) return DEFAULT_ACCOUNT_ID;
+
+  // Explicit defaultAccount setting
+  if (channel.defaultAccount) return channel.defaultAccount;
+
+  // First account from accounts map
+  if (channel.accounts && typeof channel.accounts === 'object') {
+    const ids = Object.keys(channel.accounts);
+    if (ids.length > 0) return ids[0];
+  }
+
   return DEFAULT_ACCOUNT_ID;
 }
 
+/**
+ * Deduplicate accounts by clientId: if multiple accounts share the same
+ * clientId, only the first one is kept. Returns filtered account IDs.
+ */
+export function deduplicateByClientId(cfg: any, accountIds: string[]): string[] {
+  const seen = new Set<string>();
+  return accountIds.filter(id => {
+    const account = resolveDingTalkAccount({ cfg, accountId: id });
+    if (!account.clientId) return true;
+    if (seen.has(account.clientId)) {
+      console.warn(`[dingtalk] Duplicate clientId "${account.clientId}" in account "${id}", skipping`);
+      return false;
+    }
+    seen.add(account.clientId);
+    return true;
+  });
+}
+
+/**
+ * Resolve a single account by ID.
+ * Merges top-level base config with per-account overrides.
+ * Env vars only apply to the default account.
+ */
 export function resolveDingTalkAccount(params: {
   cfg: any;
   accountId?: string | null;
 }): ResolvedDingTalkAccount {
   const accountId = params.accountId?.trim() || DEFAULT_ACCOUNT_ID;
-  const rawConfig = params.cfg?.channels?.dingtalk ?? {};
-
-  // Merge configuration with environment variables
-  // Environment variables serve as fallback for missing config values
-  const configWithEnv = {
-    ...rawConfig,
-    clientId: rawConfig.clientId || process.env[ENV_CLIENT_ID],
-    clientSecret: rawConfig.clientSecret || process.env[ENV_CLIENT_SECRET],
-    robotCode: rawConfig.robotCode || process.env[ENV_ROBOT_CODE],
+  const rawChannel = params.cfg?.channels?.dingtalk ?? {};
+
+  // Separate base config from multi-account fields
+  const { accounts, defaultAccount, ...baseConfig } = rawChannel;
+
+  // Get per-account override (if accounts map exists and this account is in it)
+  let accountOverride: Record<string, any> = {};
+  if (accounts && typeof accounts === 'object' && accountId !== DEFAULT_ACCOUNT_ID) {
+    accountOverride = accounts[accountId] ?? {};
+  } else if (accounts && typeof accounts === 'object' && accountId === DEFAULT_ACCOUNT_ID) {
+    // "default" may also be an explicit key in accounts map
+    accountOverride = accounts[DEFAULT_ACCOUNT_ID] ?? {};
+  }
+
+  // Merge: base + account override (deep merge for `dm` object)
+  // Credentials (clientId, clientSecret, robotCode) are per-account and should NOT
+  // inherit from base — otherwise bot A's robotCode leaks into bot B's config.
+  const { clientId: _baseClientId, clientSecret: _baseClientSecret, robotCode: _baseRobotCode, ...baseNonCreds } = baseConfig;
+  const merged = {
+    ...baseNonCreds,
+    ...accountOverride,
+    // Credentials: use account override first, then base, but robotCode only inherits
+    // if clientId also inherits (i.e. they belong to the same bot)
+    clientId: accountOverride.clientId || baseConfig.clientId,
+    clientSecret: accountOverride.clientSecret || baseConfig.clientSecret,
+    robotCode: accountOverride.robotCode || (accountOverride.clientId ? undefined : baseConfig.robotCode),
+    // Deep merge dm
+    dm: { ...(baseConfig.dm ?? {}), ...(accountOverride.dm ?? {}) },
+    // Deep merge groups
+    groups: { ...(baseConfig.groups ?? {}), ...(accountOverride.groups ?? {}) },
   };
 
-  // Validate configuration with Zod
-  let validatedConfig: DingTalkConfig;
+  // Env var fallback only for default account
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    merged.clientId = merged.clientId || process.env[ENV_CLIENT_ID];
+    merged.clientSecret = merged.clientSecret || process.env[ENV_CLIENT_SECRET];
+    merged.robotCode = merged.robotCode || process.env[ENV_ROBOT_CODE];
+  }
+
+  // Validate merged config
+  let validatedConfig: DingTalkAccountConfig;
   let credentialSource: "config" | "env" | "none" = "none";
 
   try {
-    validatedConfig = validateDingTalkConfig(configWithEnv);
+    validatedConfig = validateDingTalkAccountConfig(merged);
 
     // Determine credential source
-    if (rawConfig.clientId && rawConfig.clientSecret) {
+    const rawClientId = accountOverride.clientId || baseConfig.clientId;
+    const rawClientSecret = accountOverride.clientSecret || baseConfig.clientSecret;
+    if (rawClientId && rawClientSecret) {
       credentialSource = "config";
     } else if (validatedConfig.clientId && validatedConfig.clientSecret) {
       credentialSource = "env";
     }
   } catch (error) {
-    // If validation fails, throw a helpful error message
     const errorMsg = error instanceof Error ? error.message : String(error);
     throw new Error(
       `DingTalk configuration validation failed for account "${accountId}":\n${errorMsg}\n\n` +
-      `Please check your configuration at channels.dingtalk or set environment variables:\n` +
+      `Please check your configuration at channels.dingtalk` +
+      (accountId !== DEFAULT_ACCOUNT_ID ? `.accounts.${accountId}` : '') +
+      ` or set environment variables:\n` +
       `  - ${ENV_CLIENT_ID}\n` +
       `  - ${ENV_CLIENT_SECRET}\n` +
       `  - ${ENV_ROBOT_CODE} (optional)`
@@ -61,7 +146,7 @@ export function resolveDingTalkAccount(params: {
 
   return {
     accountId,
-    name: "DingTalk Bot",
+    name: validatedConfig.name || (accountId === DEFAULT_ACCOUNT_ID ? "DingTalk Bot" : accountId),
     enabled: validatedConfig.enabled,
     configured,
     clientId: validatedConfig.clientId,

package/src/api.ts

@@ -882,6 +882,73 @@ export async function recallGroupMessages(params: {
  * Typing indicator helper - sends a "thinking" message that will be recalled
  * Returns a cleanup function to recall the message
  */
+// ============================================================================
+// Emotion Reaction API - add/recall emoji reactions on user messages
+// Cleaner UX than typing indicators: reaction floats on the message itself
+// ============================================================================
+
+export async function addEmotionReply(params: {
+  clientId: string;
+  clientSecret: string;
+  robotCode: string;
+  msgId: string;
+  conversationId: string;
+  emotionName?: string;
+}): Promise<{ cleanup: () => Promise<void>; error?: string }> {
+  const emotionName = params.emotionName || '🤔思考中';
+  try {
+    const token = await getDingTalkAccessToken(params.clientId, params.clientSecret);
+    const res = await jsonPost(
+      `${DINGTALK_API_BASE}/robot/emotion/reply`,
+      {
+        robotCode: params.robotCode,
+        openMsgId: params.msgId,
+        openConversationId: params.conversationId,
+        emotionType: 2,
+        emotionName,
+        textEmotion: {
+          emotionId: "2659900",
+          emotionName,
+          text: emotionName,
+          backgroundId: "im_bg_1",
+        },
+      },
+      { "x-acs-dingtalk-access-token": token },
+    );
+
+    if (res?.errcode && res.errcode !== 0) {
+      return { cleanup: async () => {}, error: `emotion reply failed: ${res.errmsg || res.errcode}` };
+    }
+
+    return {
+      cleanup: async () => {
+        try {
+          const t = await getDingTalkAccessToken(params.clientId, params.clientSecret);
+          await jsonPost(
+            `${DINGTALK_API_BASE}/robot/emotion/recall`,
+            {
+              robotCode: params.robotCode,
+              openMsgId: params.msgId,
+              openConversationId: params.conversationId,
+              emotionType: 2,
+              emotionName,
+              textEmotion: {
+                emotionId: "2659900",
+                emotionName,
+                text: emotionName,
+                backgroundId: "im_bg_1",
+              },
+            },
+            { "x-acs-dingtalk-access-token": t },
+          );
+        } catch (_) { /* best-effort recall */ }
+      },
+    };
+  } catch (err) {
+    return { cleanup: async () => {}, error: String(err) };
+  }
+}
+
 export async function sendTypingIndicator(params: {
   clientId: string;
   clientSecret: string;

package/src/channel.ts

@@ -1,5 +1,5 @@
 import { getDingTalkRuntime } from './runtime.js';
-import { resolveDingTalkAccount } from './accounts.js';
+import { resolveDingTalkAccount, listDingTalkAccountIds, resolveDefaultDingTalkAccountId } from './accounts.js';
 import { startDingTalkMonitor } from './monitor.js';
 import { sendDingTalkRestMessage, uploadMediaFile, sendFileMessage, textToMarkdownFile } from './api.js';
 import { probeDingTalk } from './probe.js';
@@ -132,27 +132,35 @@ export const dingtalkPlugin = {
     },
 
     listAccountIds(cfg) {
-      const channel = cfg?.channels?.dingtalk ?? {};
-      if (channel.clientId) return ['default'];
-      return [];
+      return listDingTalkAccountIds(cfg);
     },
 
     resolveAccount(cfg, accountId) {
       return resolveDingTalkAccount({ cfg, accountId });
     },
 
-    defaultAccountId() {
-      return 'default';
+    defaultAccountId(cfg) {
+      return resolveDefaultDingTalkAccountId(cfg);
     },
 
     setAccountEnabled({ cfg, accountId, enabled }) {
       const runtime = getDingTalkRuntime();
-      runtime.config.set('channels.dingtalk.enabled', enabled);
+      const channel = cfg?.channels?.dingtalk;
+      if (channel?.accounts && accountId && accountId !== 'default') {
+        runtime.config.set(`channels.dingtalk.accounts.${accountId}.enabled`, enabled);
+      } else {
+        runtime.config.set('channels.dingtalk.enabled', enabled);
+      }
     },
 
     deleteAccount({ cfg, accountId }) {
       const runtime = getDingTalkRuntime();
-      runtime.config.delete('channels.dingtalk');
+      const channel = cfg?.channels?.dingtalk;
+      if (channel?.accounts && accountId && accountId !== 'default') {
+        runtime.config.delete(`channels.dingtalk.accounts.${accountId}`);
+      } else {
+        runtime.config.delete('channels.dingtalk');
+      }
     },
 
     isConfigured(account) {

package/src/config-schema.ts

@@ -1,151 +1,167 @@
-import { z } from 'zod';
-
-// 定义枚举类型
-export const dmPolicySchema = z.enum(['disabled', 'pairing', 'allowlist', 'open'], {
-  description: 'DM access control policy',
-});
-
-export const groupPolicySchema = z.enum(['disabled', 'allowlist', 'open'], {
-  description: 'Group chat access control policy',
-});
-
-export const messageFormatSchema = z.enum(['text', 'markdown', 'richtext', 'auto'], {
-  description: 'Message format for bot responses (richtext is an alias for markdown, auto detects markdown features)',
-});
-
-export const longTextModeSchema = z.enum(['chunk', 'file']);
-
-// DingTalk 配置 Schema
-export const dingTalkConfigSchema = z.object({
-  enabled: z.boolean().default(true).describe('Enable DingTalk channel'),
-
-  // 凭证配置（必需）
-  clientId: z.string().min(1, 'Client ID (AppKey) is required')
-    .describe('DingTalk application AppKey'),
-  clientSecret: z.string().min(1, 'Client Secret (AppSecret) is required')
-    .describe('DingTalk application AppSecret'),
-  robotCode: z.string().optional()
-    .describe('Robot code (optional, defaults to clientId if not provided)'),
-
-  // 私聊配置
-  dm: z.object({
-    enabled: z.boolean().default(true)
-      .describe('Enable direct messages'),
-    policy: dmPolicySchema.default('pairing')
-      .describe(
-        'Access control policy:\n' +
-        '  - disabled: No DM allowed\n' +
-        '  - pairing: Show staffId on first contact, admin adds to allowlist\n' +
-        '  - allowlist: Only specified users can DM\n' +
-        '  - open: Anyone can DM (not recommended)'
-      ),
-    allowFrom: z.array(z.string()).default([])
-      .describe('Allowed staff IDs (for pairing/allowlist policy)'),
-  }).default({}),
-
-  // 群聊配置
-  groupPolicy: groupPolicySchema.default('allowlist')
-    .describe(
-      'Group chat policy:\n' +
-      '  - disabled: No groups\n' +
-      '  - allowlist: Only specified groups\n' +
-      '  - open: All groups'
-    ),
-  groupAllowlist: z.array(z.string()).default([])
-    .describe('Allowed group conversation IDs (only used when groupPolicy is "allowlist")'),
-  requireMention: z.boolean().default(true)
-    .describe('Require @ mention in group chats'),
-
-  // 消息格式
-  messageFormat: messageFormatSchema.default('text')
-    .describe(
-      'Message format:\n' +
-      '  - text: Plain text (recommended, supports tables)\n' +
-      '  - markdown: DingTalk markdown (limited support, no tables)\n' +
-      '  - richtext: Alias for markdown (deprecated, use markdown instead)\n' +
-      '  - auto: Auto-detect markdown features in response'
-    ),
-
-  // 思考反馈
-  showThinking: z.boolean().default(false)
-    .describe('Send "正在思考..." feedback before AI responds'),
-
-  // 高级配置（可选）
-  textChunkLimit: z.number().int().positive().default(2000).optional()
-    .describe('Text chunk size limit for long messages'),
-
-  // 长文本处理
-  longTextMode: longTextModeSchema.default('chunk')
-    .describe(
-      'How to handle long text messages:\n' +
-      '  - chunk: Split into multiple messages (default, same as official channels)\n' +
-      '  - file: Convert to .md file and send as attachment'
-    ),
-  longTextThreshold: z.number().int().positive().default(8000).optional()
-    .describe('Character threshold for longTextMode=file (default 8000)'),
-
-  // 每群聊覆盖配置
-  groups: z.record(z.string(), z.object({
-    systemPrompt: z.string().optional()
-      .describe('Per-group extra system prompt injected as GroupSystemPrompt'),
-    enabled: z.boolean().optional()
-      .describe('Disable this group (false = ignore all messages)'),
-  })).optional().default({})
-    .describe('Per-group overrides keyed by conversationId'),
-
-  // 消息聚合
-  messageAggregation: z.boolean().default(true)
-    .describe(
-      'Aggregate messages from the same sender within a short time window.\n' +
-      'Useful when DingTalk splits link cards into multiple messages.'
-    ),
-  messageAggregationDelayMs: z.number().int().positive().default(2000).optional()
-    .describe('Time window in milliseconds to wait for additional messages (default 2000)'),
-}).passthrough();
-
-// 导出配置类型
-export type DingTalkConfig = z.infer<typeof dingTalkConfigSchema>;
-
-/**
- * 验证 DingTalk 配置
- * @param config - 原始配置对象
- * @returns 验证后的配置
- * @throws ZodError 如果配置无效
- */
-export function validateDingTalkConfig(config: unknown): DingTalkConfig {
-  try {
-    return dingTalkConfigSchema.parse(config);
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const formatted = error.issues.map(e => {
-        const path = e.path.join('.');
-        return `  - ${path || 'root'}: ${e.message}`;
-      }).join('\n');
-      throw new Error(`DingTalk config validation failed:\n${formatted}`);
-    }
-    throw error;
-  }
-}
-
-/**
- * 安全地验证配置，返回错误而不抛出异常
- * @param config - 原始配置对象
- * @returns { success: true, data } 或 { success: false, error }
- */
-export function safeValidateDingTalkConfig(config: unknown):
-  | { success: true; data: DingTalkConfig }
-  | { success: false; error: string } {
-  try {
-    const data = dingTalkConfigSchema.parse(config);
-    return { success: true, data };
-  } catch (error) {
-    if (error instanceof z.ZodError) {
-      const formatted = error.issues.map(e => {
-        const path = e.path.join('.');
-        return `${path || 'root'}: ${e.message}`;
-      }).join('; ');
-      return { success: false, error: formatted };
-    }
-    return { success: false, error: String(error) };
-  }
-}
+import { z } from 'zod';
+
+// 定义枚举类型
+export const dmPolicySchema = z.enum(['disabled', 'pairing', 'allowlist', 'open'], {
+  description: 'DM access control policy',
+});
+
+export const groupPolicySchema = z.enum(['disabled', 'allowlist', 'open'], {
+  description: 'Group chat access control policy',
+});
+
+export const messageFormatSchema = z.enum(['text', 'markdown', 'richtext', 'auto'], {
+  description: 'Message format for bot responses (richtext is an alias for markdown, auto detects markdown features)',
+});
+
+export const longTextModeSchema = z.enum(['chunk', 'file']);
+
+// Per-account config schema (everything that can be overridden per account)
+export const dingTalkAccountConfigSchema = z.object({
+  enabled: z.boolean().default(true).describe('Enable this account'),
+  name: z.string().optional().describe('Display name for this account'),
+
+  // Credentials
+  clientId: z.string().optional()
+    .describe('DingTalk application AppKey'),
+  clientSecret: z.string().optional()
+    .describe('DingTalk application AppSecret'),
+  robotCode: z.string().optional()
+    .describe('Robot code (optional, defaults to clientId if not provided)'),
+
+  // DM config
+  dm: z.object({
+    enabled: z.boolean().default(true)
+      .describe('Enable direct messages'),
+    policy: dmPolicySchema.default('pairing')
+      .describe(
+        'Access control policy:\n' +
+        '  - disabled: No DM allowed\n' +
+        '  - pairing: Show staffId on first contact, admin adds to allowlist\n' +
+        '  - allowlist: Only specified users can DM\n' +
+        '  - open: Anyone can DM (not recommended)'
+      ),
+    allowFrom: z.array(z.string()).default([])
+      .describe('Allowed staff IDs (for pairing/allowlist policy)'),
+  }).default({}),
+
+  // Group config
+  groupPolicy: groupPolicySchema.default('allowlist')
+    .describe(
+      'Group chat policy:\n' +
+      '  - disabled: No groups\n' +
+      '  - allowlist: Only specified groups\n' +
+      '  - open: All groups'
+    ),
+  groupAllowlist: z.array(z.string()).default([])
+    .describe('Allowed group conversation IDs (only used when groupPolicy is "allowlist")'),
+  requireMention: z.boolean().default(true)
+    .describe('Require @ mention in group chats'),
+
+  // Message format
+  messageFormat: messageFormatSchema.default('text')
+    .describe(
+      'Message format:\n' +
+      '  - text: Plain text (recommended, supports tables)\n' +
+      '  - markdown: DingTalk markdown (limited support, no tables)\n' +
+      '  - richtext: Alias for markdown (deprecated, use markdown instead)\n' +
+      '  - auto: Auto-detect markdown features in response'
+    ),
+
+  // Thinking feedback
+  showThinking: z.boolean().default(false)
+    .describe('Send "正在思考..." feedback before AI responds'),
+
+  // Advanced
+  textChunkLimit: z.number().int().positive().default(2000).optional()
+    .describe('Text chunk size limit for long messages'),
+
+  longTextMode: longTextModeSchema.default('chunk')
+    .describe(
+      'How to handle long text messages:\n' +
+      '  - chunk: Split into multiple messages (default, same as official channels)\n' +
+      '  - file: Convert to .md file and send as attachment'
+    ),
+  longTextThreshold: z.number().int().positive().default(8000).optional()
+    .describe('Character threshold for longTextMode=file (default 8000)'),
+
+  // Per-group overrides
+  groups: z.record(z.string(), z.object({
+    systemPrompt: z.string().optional()
+      .describe('Per-group extra system prompt injected as GroupSystemPrompt'),
+    enabled: z.boolean().optional()
+      .describe('Disable this group (false = ignore all messages)'),
+  })).optional().default({})
+    .describe('Per-group overrides keyed by conversationId'),
+
+  // Message aggregation
+  messageAggregation: z.boolean().default(true)
+    .describe(
+      'Aggregate messages from the same sender within a short time window.\n' +
+      'Useful when DingTalk splits link cards into multiple messages.'
+    ),
+  messageAggregationDelayMs: z.number().int().positive().default(2000).optional()
+    .describe('Time window in milliseconds to wait for additional messages (default 2000)'),
+}).passthrough();
+
+// Top-level DingTalk config: account config + multi-account support
+export const dingTalkConfigSchema = dingTalkAccountConfigSchema.extend({
+  accounts: z.record(z.string(), dingTalkAccountConfigSchema.partial().optional()).optional()
+    .describe('Named accounts that override top-level settings'),
+  defaultAccount: z.string().optional()
+    .describe('Default account ID (if accounts are defined)'),
+});
+
+// 导出配置类型
+export type DingTalkAccountConfig = z.infer<typeof dingTalkAccountConfigSchema>;
+export type DingTalkConfig = z.infer<typeof dingTalkConfigSchema>;
+
+/**
+ * 验证 DingTalk 配置
+ * @param config - 原始配置对象
+ * @returns 验证后的配置
+ * @throws ZodError 如果配置无效
+ */
+export function validateDingTalkConfig(config: unknown): DingTalkConfig {
+  try {
+    return dingTalkConfigSchema.parse(config);
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const formatted = error.issues.map(e => {
+        const path = e.path.join('.');
+        return `  - ${path || 'root'}: ${e.message}`;
+      }).join('\n');
+      throw new Error(`DingTalk config validation failed:\n${formatted}`);
+    }
+    throw error;
+  }
+}
+
+/**
+ * Validate per-account config (partial, used for account overrides)
+ */
+export function validateDingTalkAccountConfig(config: unknown): DingTalkAccountConfig {
+  return dingTalkAccountConfigSchema.parse(config);
+}
+
+/**
+ * 安全地验证配置，返回错误而不抛出异常
+ * @param config - 原始配置对象
+ * @returns { success: true, data } 或 { success: false, error }
+ */
+export function safeValidateDingTalkConfig(config: unknown):
+  | { success: true; data: DingTalkConfig }
+  | { success: false; error: string } {
+  try {
+    const data = dingTalkConfigSchema.parse(config);
+    return { success: true, data };
+  } catch (error) {
+    if (error instanceof z.ZodError) {
+      const formatted = error.issues.map(e => {
+        const path = e.path.join('.');
+        return `${path || 'root'}: ${e.message}`;
+      }).join('; ');
+      return { success: false, error: formatted };
+    }
+    return { success: false, error: String(error) };
+  }
+}

package/src/monitor.ts

@@ -1,5 +1,5 @@
 import type { DingTalkRobotMessage, ResolvedDingTalkAccount, ExtractedMessage } from "./types.js";
-import { sendViaSessionWebhook, sendMarkdownViaSessionWebhook, sendDingTalkRestMessage, batchGetUserInfo, downloadPicture, downloadMediaFile, cleanupOldMedia, uploadMediaFile, sendFileMessage, textToMarkdownFile, sendTypingIndicator } from "./api.js";
+import { sendViaSessionWebhook, sendMarkdownViaSessionWebhook, sendDingTalkRestMessage, batchGetUserInfo, downloadPicture, downloadMediaFile, cleanupOldMedia, uploadMediaFile, sendFileMessage, textToMarkdownFile, sendTypingIndicator, addEmotionReply } from "./api.js";
 import { getDingTalkRuntime } from "./runtime.js";
 import { cacheInboundDownloadCode, getCachedDownloadCode } from "./quoted-msg-cache.js";
 import { resolveQuotedFile } from "./quoted-file-service.js";
@@ -253,8 +253,14 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
     abortSignal.addEventListener('abort', () => {
       clearInterval(cleanupInterval);
       clearInterval(queueCleanupInterval);
-      sessionQueues.clear();
-      sessionQueueLastActivity.clear();
+      // Only clear this account's queue entries (other accounts may still be running)
+      const prefix = account.accountId + ':';
+      for (const key of sessionQueues.keys()) {
+        if (key.startsWith(prefix)) sessionQueues.delete(key);
+      }
+      for (const key of sessionQueueLastActivity.keys()) {
+        if (key.startsWith(prefix)) sessionQueueLastActivity.delete(key);
+      }
     });
   }
 
@@ -275,7 +281,7 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
   const client = new DWClient({
     clientId: account.clientId,
     clientSecret: account.clientSecret,
-    keepAlive: true,       // Enable SDK ping/pong for socket-level liveness
+    keepAlive: false,      // Disabled: SDK's 8s ping/pong terminates on unreachable gateway endpoints
     autoReconnect: false,  // We manage reconnection with exponential backoff
   });
 
@@ -1442,30 +1448,55 @@ async function dispatchMessageInternal(params: {
   // Typing indicator cleanup function (will be called after dispatch completes)
   let typingCleanup: (() => Promise<void>) | null = null;
 
-  // Send typing indicator (recallable) if enabled
-  // This replaces the old showThinking feature with a better UX - the indicator disappears when reply arrives
+  // Send thinking feedback: prefer emotion reaction (clean UX, floats on message),
+  // fall back to typing indicator (separate message) if emotion API fails or msgId unavailable.
   if (account.config.typingIndicator !== false && account.clientId && account.clientSecret) {
-    try {
-      const typingMessage = account.config.typingIndicatorMessage || '⏳ 思考中...';
-      const robotCode = account.robotCode || account.clientId;
-      
-      const result = await sendTypingIndicator({
-        clientId: account.clientId,
-        clientSecret: account.clientSecret,
-        robotCode,
-        userId: isDm ? senderId : undefined,
-        conversationId: !isDm ? conversationId : undefined,
-        message: typingMessage,
-      });
-      
-      if (result.error) {
-        log?.info?.('[dingtalk] Typing indicator failed: ' + result.error);
-      } else {
-        typingCleanup = result.cleanup;
-        log?.info?.('[dingtalk] Typing indicator sent (will be recalled on reply)');
+    const robotCode = account.robotCode || account.clientId;
+    let emotionOk = false;
+
+    // Try emotion reaction first (requires msgId + conversationId)
+    if (msg.msgId && conversationId) {
+      try {
+        const result = await addEmotionReply({
+          clientId: account.clientId,
+          clientSecret: account.clientSecret,
+          robotCode,
+          msgId: msg.msgId,
+          conversationId,
+        });
+        if (!result.error) {
+          typingCleanup = result.cleanup;
+          emotionOk = true;
+          log?.info?.('[dingtalk] Emotion reaction added (will be recalled on reply)');
+        } else {
+          log?.info?.('[dingtalk] Emotion reaction failed: ' + result.error + ', falling back to typing indicator');
+        }
+      } catch (err) {
+        log?.info?.('[dingtalk] Emotion reaction error: ' + err + ', falling back to typing indicator');
+      }
+    }
+
+    // Fallback to typing indicator (separate message)
+    if (!emotionOk) {
+      try {
+        const typingMessage = account.config.typingIndicatorMessage || '⏳ 思考中...';
+        const result = await sendTypingIndicator({
+          clientId: account.clientId,
+          clientSecret: account.clientSecret,
+          robotCode,
+          userId: isDm ? senderId : undefined,
+          conversationId: !isDm ? conversationId : undefined,
+          message: typingMessage,
+        });
+        if (!result.error) {
+          typingCleanup = result.cleanup;
+          log?.info?.('[dingtalk] Typing indicator sent (will be recalled on reply)');
+        } else {
+          log?.info?.('[dingtalk] Typing indicator failed: ' + result.error);
+        }
+      } catch (err) {
+        log?.info?.('[dingtalk] Typing indicator error: ' + err);
       }
-    } catch (err) {
-      log?.info?.('[dingtalk] Typing indicator error: ' + err);
     }
   }
   // Legacy: Send thinking feedback (opt-in, non-recallable) - only if typingIndicator is explicitly disabled
@@ -1530,7 +1561,7 @@ async function dispatchMessageInternal(params: {
         RawBody: rawBody,
         CommandBody: rawBody,
         From: "dingtalk:" + senderId,
-        To: isDm ? ("dingtalk:dm:" + senderId) : ("dingtalk:group:" + conversationId),
+        To: isDm ? ("dingtalk:" + account.accountId + ":dm:" + senderId) : ("dingtalk:" + account.accountId + ":group:" + conversationId),
         SessionKey: sessionKey,
         AccountId: account.accountId,
         ChatType: isDm ? "direct" : "group",
@@ -1616,22 +1647,53 @@ async function dispatchWithFullPipeline(params: {
   
   let firstReplyFired = false;
 
-  // 1. Resolve agent route
+  // 1. Resolve agent route via own bindings matching (like official plugin).
+  // OpenClaw's resolveAgentRoute doesn't handle accountId correctly for multi-account.
+  const peerId = isDm ? senderId : conversationId;
+  const peerKind = isDm ? 'dm' : 'group';
+  const chatType = isDm ? 'direct' : 'group';
+
+  let matchedAgentId: string | null = null;
+  const bindings = (cfg as any)?.bindings;
+  if (Array.isArray(bindings) && bindings.length > 0) {
+    for (const binding of bindings) {
+      const match = binding.match;
+      if (!match) continue;
+      if (match.channel && match.channel !== 'dingtalk') continue;
+      if (match.accountId && match.accountId !== account.accountId) continue;
+      if (match.peer) {
+        if (match.peer.kind && match.peer.kind !== chatType) continue;
+        if (match.peer.id && match.peer.id !== '*' && match.peer.id !== peerId) continue;
+      }
+      matchedAgentId = binding.agentId;
+      break;
+    }
+  }
+  if (!matchedAgentId) {
+    matchedAgentId = (cfg as any)?.defaultAgent || 'main';
+  }
+
+  // Use OpenClaw's resolveAgentRoute with our matched agentId to get a valid sessionKey.
+  // Pass accountId-prefixed peerId to ensure session isolation between accounts.
   const route = rt.channel.routing.resolveAgentRoute({
     cfg,
     channel: 'dingtalk',
     accountId: account.accountId,
-    peer: { kind: isDm ? 'dm' : 'group', id: isDm ? senderId : conversationId },
+    agentId: matchedAgentId,
+    peer: { kind: peerKind, id: `${account.accountId}:${peerId}` },
   });
+  const sessionKey = route.sessionKey;
+
+  log?.info?.(`[dingtalk] Route resolved: agentId=${matchedAgentId} sessionKey=${sessionKey} accountId=${account.accountId}`);
 
   // 2. Resolve store path
-  const storePath = rt.channel.session?.resolveStorePath?.(cfg?.session?.store, { agentId: route.agentId });
+  const storePath = rt.channel.session?.resolveStorePath?.(cfg?.session?.store, { agentId: matchedAgentId });
 
   // 3. Get envelope format options
   const envelopeOptions = rt.channel.reply?.resolveEnvelopeFormatOptions?.(cfg) ?? {};
 
   // 4. Read previous timestamp for session continuity
-  const previousTimestamp = rt.channel.session?.readSessionUpdatedAt?.({ storePath, sessionKey: route.sessionKey });
+  const previousTimestamp = rt.channel.session?.readSessionUpdatedAt?.({ storePath, sessionKey: sessionKey });
 
   // 5. Format inbound envelope
   const fromLabel = isDm ? `${senderName} (${senderId})` : `${msg.conversationTitle || conversationId} - ${senderName}`;
@@ -1642,7 +1704,7 @@ async function dispatchWithFullPipeline(params: {
   }) ?? rawBody;
 
   // 6. Finalize inbound context (includes media info)
-  const to = isDm ? `dingtalk:dm:${senderId}` : `dingtalk:group:${conversationId}`;
+  const to = isDm ? `dingtalk:${account.accountId}:dm:${senderId}` : `dingtalk:${account.accountId}:group:${conversationId}`;
 
   // 6a. Per-group system prompt (read from account.config.groups)
   const groupsConfig = account?.config?.groups ?? {};
@@ -1651,7 +1713,7 @@ async function dispatchWithFullPipeline(params: {
 
   const ctx = rt.channel.reply.finalizeInboundContext({
     Body: body, RawBody: rawBody, CommandBody: rawBody, From: to, To: to,
-    SessionKey: route.sessionKey, AccountId: account.accountId,
+    SessionKey: sessionKey, AccountId: account.accountId,
     ChatType: isDm ? 'direct' : 'group',
     ConversationLabel: fromLabel,
     GroupSubject: isDm ? undefined : (msg.conversationTitle || conversationId),
@@ -1667,7 +1729,7 @@ async function dispatchWithFullPipeline(params: {
   // 7. Record inbound session
   if (rt.channel.session?.recordInboundSession) {
     await rt.channel.session.recordInboundSession({
-      storePath, sessionKey: ctx.SessionKey || route.sessionKey, ctx,
+      storePath, sessionKey: ctx.SessionKey || sessionKey, ctx,
       updateLastRoute: isDm ? { sessionKey: route.mainSessionKey, channel: 'dingtalk', to: senderId, accountId: account.accountId } : undefined,
     });
   }

package/src/types.ts

@@ -72,5 +72,7 @@ export interface DingTalkChannelConfig {
   textChunkLimit?: number;
   messageFormat?: 'text' | 'markdown' | 'richtext' | 'auto';
   showThinking?: boolean;
+  accounts?: Record<string, Partial<DingTalkChannelConfig>>;
+  defaultAccount?: string;
   [key: string]: unknown;
 }