@yaoyuanchao/dingtalk 1.6.0 → 1.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yaoyuanchao/dingtalk",
-  "version": "1.6.0",
+  "version": "1.7.0",
   "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/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

@@ -190,6 +190,32 @@ interface BufferedMessage {
 const messageBuffer = new Map<string, BufferedMessage>();
 const AGGREGATION_DELAY_MS = 2000; // 2 seconds - balance between UX and catching split messages
 
+// ============================================================================
+// Per-Session Message Queue - serializes dispatch to prevent concurrent
+// processing of messages in the same conversation. Uses Promise chaining:
+// each new message's dispatch waits for the previous one to complete.
+// ============================================================================
+
+const sessionQueues = new Map<string, Promise<void>>();
+const sessionQueueLastActivity = new Map<string, number>();
+const SESSION_QUEUE_TTL_MS = 5 * 60 * 1000; // 5 min
+
+const QUEUE_BUSY_PHRASES = [
+  "收到，前面还有消息在处理，稍后按顺序继续。",
+  "当前正在处理中，你的新消息已排队，完成后马上继续。",
+  "我还在处理上一条，这条已记下，稍后继续。",
+];
+
+/** Clean up expired session queues (runs periodically) */
+function cleanupExpiredSessionQueues(): void {
+  const now = Date.now();
+  for (const [key, ts] of sessionQueueLastActivity) {
+    if (now - ts > SESSION_QUEUE_TTL_MS && !sessionQueues.has(key)) {
+      sessionQueueLastActivity.delete(key);
+    }
+  }
+}
+
 function getBufferKey(msg: DingTalkRobotMessage, accountId: string): string {
   return `${accountId}:${msg.conversationId}:${msg.senderId || msg.senderStaffId}`;
 }
@@ -219,10 +245,22 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
     cleanupOldMedia();
   }, 60 * 60 * 1000); // 1 hour
 
+  // Schedule session queue cleanup every 60s
+  const queueCleanupInterval = setInterval(cleanupExpiredSessionQueues, 60_000);
+
   // Clean up on abort (only if abortSignal is provided)
   if (abortSignal) {
     abortSignal.addEventListener('abort', () => {
       clearInterval(cleanupInterval);
+      clearInterval(queueCleanupInterval);
+      // 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);
+      }
     });
   }
 
@@ -243,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
   });
 
@@ -299,10 +337,10 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
   while (!abortSignal?.aborted) {
     try {
       await client.connect();
-      reconnectAttempt = 0;
-      lastActivityTime = Date.now();
+      const connectTime = Date.now();
+      lastActivityTime = connectTime;
       log?.info?.("[dingtalk:" + account.accountId + "] Stream connected");
-      setStatus?.({ running: true, lastStartAt: Date.now() });
+      setStatus?.({ running: true, lastStartAt: connectTime });
 
       // Start heartbeat monitor: if no activity for 5 minutes, force disconnect to trigger reconnect.
       // The SDK's keepAlive ping/pong (8s interval) handles socket-level liveness and sets
@@ -331,6 +369,13 @@ export async function startDingTalkMonitor(ctx: DingTalkMonitorContext): Promise
           }, { once: true });
         }
       });
+
+      // Only reset backoff if connection was stable (survived > 30s)
+      // This prevents rapid reconnect loops when connect() succeeds but
+      // the socket drops immediately (e.g. gateway returns unreachable endpoint)
+      if (Date.now() - connectTime > 30_000) {
+        reconnectAttempt = 0;
+      }
     } catch (err) {
       log?.warn?.("[dingtalk] Connection error: " + (err instanceof Error ? err.message : String(err)));
     }
@@ -1308,6 +1353,7 @@ async function flushMessageBuffer(bufferKey: string): Promise<void> {
 
 /**
  * Dispatch a message to the agent (after aggregation or immediately).
+ * Enqueues into per-session queue to prevent concurrent processing.
  */
 async function dispatchMessage(params: {
   ctx: DingTalkMonitorContext;
@@ -1321,6 +1367,78 @@ async function dispatchMessage(params: {
   conversationId: string;
   mediaPath?: string;
   mediaType?: string;
+}): Promise<void> {
+  const { ctx, conversationId } = params;
+  const { account, log } = ctx;
+
+  const queueKey = `${account.accountId}:${conversationId}`;
+  const isQueueBusy = sessionQueues.has(queueKey);
+
+  // If queue is busy, send a recallable notification so it disappears when processing starts
+  let queueAckCleanup: (() => Promise<void>) | null = null;
+  if (isQueueBusy) {
+    const phrase = QUEUE_BUSY_PHRASES[Math.floor(Math.random() * QUEUE_BUSY_PHRASES.length)];
+    log?.info?.("[dingtalk] Queue busy for " + queueKey + ", notifying user");
+    try {
+      if (account.clientId && account.clientSecret) {
+        const robotCode = account.robotCode || account.clientId;
+        const result = await sendTypingIndicator({
+          clientId: account.clientId,
+          clientSecret: account.clientSecret,
+          robotCode,
+          userId: params.isDm ? params.senderId : undefined,
+          conversationId: !params.isDm ? conversationId : undefined,
+          message: '⏳ ' + phrase,
+        });
+        if (!result.error) {
+          queueAckCleanup = result.cleanup;
+        }
+      }
+    } catch (_) { /* best-effort notification */ }
+  }
+
+  // Enqueue: chain onto previous task
+  const previousTask = sessionQueues.get(queueKey) || Promise.resolve();
+  const currentTask = previousTask
+    .then(async () => {
+      // Recall queue-busy notification before starting actual processing
+      if (queueAckCleanup) {
+        try { await queueAckCleanup(); log?.info?.("[dingtalk] Queue ack recalled, starting processing"); } catch (_) {}
+      }
+      await dispatchMessageInternal(params);
+    })
+    .catch((err) => {
+      log?.info?.("[dingtalk] Queued dispatch error: " + (err instanceof Error ? err.message : String(err)));
+    })
+    .finally(() => {
+      sessionQueueLastActivity.set(queueKey, Date.now());
+      // Clean up only if this is still the latest task
+      if (sessionQueues.get(queueKey) === currentTask) {
+        sessionQueues.delete(queueKey);
+      }
+    });
+
+  sessionQueues.set(queueKey, currentTask);
+  sessionQueueLastActivity.set(queueKey, Date.now());
+
+  // Don't await — fire-and-forget so message buffering and SDK callback stay responsive
+}
+
+/**
+ * Internal dispatch: actually processes the message (typing indicator, agent call, reply).
+ */
+async function dispatchMessageInternal(params: {
+  ctx: DingTalkMonitorContext;
+  msg: DingTalkRobotMessage;
+  rawBody: string;
+  replyTarget: any;
+  sessionKey: string;
+  isDm: boolean;
+  senderId: string;
+  senderName: string;
+  conversationId: string;
+  mediaPath?: string;
+  mediaType?: string;
 }): Promise<void> {
   const { ctx, msg, rawBody, replyTarget, sessionKey, isDm, senderId, senderName, conversationId, mediaPath, mediaType } = params;
   const { account, cfg, log, setStatus } = ctx;
@@ -1418,7 +1536,7 @@ async function dispatchMessage(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",
@@ -1437,15 +1555,16 @@ async function dispatchMessage(params: {
         GroupSystemPrompt: _fallbackGroupSystemPrompt,
       };
 
-      // Fire-and-forget: don't await to avoid blocking SDK callback during long agent runs
-      runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+      // Await dispatch so per-session queue waits for reply delivery to complete
+      // before starting the next queued message.
+      await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
         ctx: ctxPayload,
         cfg: actualCfg,
         dispatcherOptions: {
           deliver: async (payload: any) => {
             // Recall typing indicator on first delivery
             await cleanupTyping();
-            
+
             log?.info?.("[dingtalk] Deliver payload keys: " + Object.keys(payload || {}).join(',') + " text?=" + (typeof payload?.text) + " markdown?=" + (typeof payload?.markdown));
             const textToSend = resolveDeliverText(payload, log);
             if (textToSend) {
@@ -1461,9 +1580,6 @@ async function dispatchMessage(params: {
             log?.info?.("[dingtalk] Reply error: " + err);
           },
         },
-      }).catch((err) => {
-        cleanupTyping().catch(() => {});
-        log?.info?.("[dingtalk] Dispatch failed: " + err);
       });
 
       // Record activity
@@ -1506,22 +1622,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}`;
@@ -1532,7 +1679,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 ?? {};
@@ -1541,7 +1688,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),
@@ -1557,7 +1704,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;
 }