@dingtalk-real-ai/dingtalk-connector 0.8.1 → 0.8.2

package/CHANGELOG.md

@@ -5,6 +5,26 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## [0.8.2] - 2026-03-22
+
+### 修复 / Fixes
+- 🐛 **多账号重复启动问题** - 修复 `enabled: false` 的账号仍会建立 WebSocket 连接的问题，禁用账号现在正确保持 pending 状态直到 Gateway 停止  
+  **Multi-account duplicate startup** - Fixed accounts with `enabled: false` still establishing WebSocket connections; disabled accounts now correctly remain in a pending state until the Gateway stops
+
+- 🐛 **相同 clientId 账号去重** - 修复多个账号配置相同 `clientId` 时建立重复连接的问题，通过静态配置分析确保同一 `clientId` 只有列表中第一个启用账号建立连接  
+  **Duplicate clientId deduplication** - Fixed duplicate connections when multiple accounts share the same `clientId`; static config analysis now ensures only the first enabled account per `clientId` establishes a connection
+
+
+### 改进 / Improvements
+- ✅ **Onboarding 配置向导优化** - 改进钉钉连接器配置引导逻辑，调整凭据输入顺序（先 Client ID 后 Client Secret），优化引导文案  
+  **Onboarding wizard improvement** - Improved DingTalk connector onboarding flow, adjusted credential input order (Client ID first, then Client Secret), and refined guidance text
+
+- ✅ **会话 Key 遵循 OpenClaw 规范** - 会话上下文按 OpenClaw 标准规则构建，通过 `channel`、`accountId`、`chatType`、`peerId` 唯一标识会话，支持 `sharedMemoryAcrossConversations` 跨会话记忆共享  
+  **Session key follows OpenClaw convention** - Session context now built per OpenClaw standard rules, uniquely identified via `channel`, `accountId`, `chatType`, `peerId`; supports `sharedMemoryAcrossConversations` for cross-conversation memory sharing
+
+- ✅ **消息处理逻辑优化** - 重构消息处理流程，提升消息响应速度和处理可靠性，确保消息按序正确处理  
+  **Message processing logic optimization** - Refactored message processing flow to improve response speed and reliability, ensuring messages are processed correctly in order
+
 ## [0.8.1] - 2026-03-20
 
 ### 修复 / Fixes

package/openclaw.plugin.json

@@ -1,7 +1,7 @@
 {
   "id": "dingtalk-connector",
   "name": "DingTalk Channel",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "DingTalk (钉钉) messaging channel via Stream mode with AI Card streaming",
   "author": "DingTalk Real Team",
   "main": "index.ts",

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@dingtalk-real-ai/dingtalk-connector",
-  "version": "0.8.1",
+  "version": "0.8.2",
   "description": "DingTalk (钉钉) channel connector — Stream mode with AI Card streaming",
   "main": "index.ts",
   "type": "module",

package/src/channel.ts

@@ -495,64 +495,64 @@ export const dingtalkPlugin: ChannelPlugin<ResolvedDingtalkAccount> = {
   gateway: {
     startAccount: async (ctx) => {
       const account = resolveDingtalkAccount({ cfg: ctx.cfg, accountId: ctx.accountId });
-      const logger = createLogger(account.config?.debug ?? false, 'DingTalk:Gateway');
+
+      // 检查账号是否启用和配置
+      if (!account.enabled) {
+        ctx.log?.info?.(`dingtalk-connector[${ctx.accountId}] is disabled, skipping startup`);
+        // 返回一个永不 resolve 的 Promise，保持 pending 状态直到 abort
+        return new Promise<void>((resolve) => {
+          if (ctx.abortSignal?.aborted) {
+            resolve();
+            return;
+          }
+          ctx.abortSignal?.addEventListener('abort', () => resolve(), { once: true });
+        });
+      }
       
-      logger.info(`startAccount 被调用：accountId=${ctx.accountId}`);
-      try {
-        logger.info('='.repeat(60));
-        logger.info('开始加载 provider 模块...');
-        const monitorModule = await import("./core/provider.ts");
-        logger.info(`monitor module 加载完成`);
-        logger.info(`monitor module keys: ${Object.keys(monitorModule).join(', ')}`);
-        logger.info(`monitorModule 类型: ${typeof monitorModule}`);
-        logger.info(`monitorModule 是否为 null: ${monitorModule === null}`);
-        logger.info(`monitorModule 是否为 undefined: ${monitorModule === undefined}`);
-        
-        // 使用 Object.getOwnPropertyDescriptor 检查属性
-        const descriptor = Object.getOwnPropertyDescriptor(monitorModule, 'monitorSingleAccount');
-        logger.info(`monitorSingleAccount descriptor: ${JSON.stringify(descriptor)}`);
-        
-        // 尝试安全地访问 monitorSingleAccount
-        let monitorSingleAccountType = 'unknown';
-        try {
-          monitorSingleAccountType = typeof monitorModule.monitorSingleAccount;
-        } catch (e) {
-          monitorSingleAccountType = `error: ${e.message}`;
-        }
-        logger.info(`monitorModule.monitorSingleAccount: ${monitorSingleAccountType}`);
-        
-        logger.info(`monitorModule.monitorDingtalkProvider: ${typeof monitorModule.monitorDingtalkProvider}`);
-        
-        // 使用直接属性访问而不是解构
-        const monitorDingtalkProvider = monitorModule.monitorDingtalkProvider;
-        logger.info(`解构 monitorDingtalkProvider 完成: ${typeof monitorDingtalkProvider}`);
-        
-        if (!monitorDingtalkProvider) {
-          ctx.log?.error?.(`monitorDingtalkProvider 未找到！可用导出: ${Object.keys(monitorModule).join(', ')}`);
-          throw new Error("monitorDingtalkProvider not found in monitor module");
+      if (!account.configured) {
+        throw new Error(`DingTalk account "${ctx.accountId}" is not properly configured`);
+      }
+      
+      // 去重检查：如果列表中排在当前账号之前的账号已使用相同 clientId，则跳过当前账号
+      // 使用静态配置分析（而非运行时状态），避免并发竞态条件
+      // 规则：同一 clientId 只有列表中第一个启用且已配置的账号才会建立连接
+      if (account.clientId) {
+        const clientId = String(account.clientId);
+        const allAccountIds = listDingtalkAccountIds(ctx.cfg);
+        const currentIndex = allAccountIds.indexOf(ctx.accountId);
+        const priorAccountWithSameClientId = allAccountIds.slice(0, currentIndex).find((otherId) => {
+          const other = resolveDingtalkAccount({ cfg: ctx.cfg, accountId: otherId });
+          return other.enabled && other.configured && other.clientId && String(other.clientId) === clientId;
+        });
+        if (priorAccountWithSameClientId) {
+          ctx.log?.info?.(
+            `dingtalk-connector[${ctx.accountId}] skipped: clientId "${clientId.substring(0, 8)}..." is already used by account "${priorAccountWithSameClientId}"`
+          );
+          return new Promise<void>((resolve) => {
+            if (ctx.abortSignal?.aborted) {
+              resolve();
+              return;
+            }
+            ctx.abortSignal?.addEventListener('abort', () => resolve(), { once: true });
+          });
         }
-        logger.info(`monitorDingtalkProvider 找到`);
-        
-        logger.info(`account 解析完成: ${account.accountId}, enabled=${account.enabled}, configured=${account.configured}`);
-        
-        ctx.setStatus({ accountId: ctx.accountId, port: null });
-        ctx.log?.info(
-          `starting dingtalk-connector[${ctx.accountId}] (mode: stream)`,
-        );
-        logger.info(`准备调用 monitorDingtalkProvider`);
-        
-        const result = await monitorDingtalkProvider({
+      }
+
+      ctx.setStatus({ accountId: ctx.accountId, port: null });
+      ctx.log?.info(
+        `starting dingtalk-connector[${ctx.accountId}] (mode: stream)`,
+      );
+      try {
+        return await monitorDingtalkProvider({
           config: ctx.cfg,
           runtime: ctx.runtime,
           abortSignal: ctx.abortSignal,
           accountId: ctx.accountId,
         });
-        logger.info(`monitorDingtalkProvider 调用完成`);
-        return result;
-      } catch (error) {
-        ctx.log?.error?.(`startAccount 发生错误: ${error.message}`);
-        ctx.log?.error?.(`错误堆栈: ${error.stack}`);
-        throw error;
+      } catch (err: any) {
+        // 打印真实错误到 stderr，绕过框架 log 系统（框架的 runtime.log 可能未初始化）
+        ctx.log?.error(`[dingtalk-connector][${ctx.accountId}] startAccount error:`, err?.message ?? err, err?.stack);
+        throw err;
       }
     },
   },

package/src/config/accounts.ts

@@ -222,9 +222,21 @@ export function resolveDingtalkAccount(params: {
 
 /**
  * List all enabled and configured accounts.
+ * Deduplicates by clientId to avoid creating multiple connections with the same credentials.
  */
 export function listEnabledDingtalkAccounts(cfg: ClawdbotConfig): ResolvedDingtalkAccount[] {
-  return listDingtalkAccountIds(cfg)
+  const accounts = listDingtalkAccountIds(cfg)
     .map((accountId) => resolveDingtalkAccount({ cfg, accountId }))
     .filter((account) => account.enabled && account.configured);
+  
+  // Deduplicate by clientId to avoid multiple connections with same credentials
+  const seen = new Set<string>();
+  return accounts.filter((account) => {
+    if (!account.clientId) return true;
+    if (seen.has(account.clientId)) {
+      return false;
+    }
+    seen.add(account.clientId);
+    return true;
+  });
 }

package/src/core/connection.ts

@@ -13,7 +13,7 @@
  * - 连接统计和监控（每分钟输出）
  */
 import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
-import type { MonitorDingtalkAccountOpts, ResolvedDingtalkAccount } from "../types/index.ts";
+import type { ResolvedDingtalkAccount } from "../types/index.ts";
 import {
   isMessageProcessed,
   markMessageProcessed,
@@ -30,14 +30,6 @@ export type DingtalkReactionCreatedEvent = {
   emoji: string;
 };
 
-export type MonitorDingtalkAccountOpts = {
-  cfg: ClawdbotConfig;
-  account: ResolvedDingtalkAccount;
-  runtime?: RuntimeEnv;
-  abortSignal?: AbortSignal;
-  messageHandler: MessageHandler; // 直接传入消息处理器
-};
-
 // 消息处理器函数类型
 export type MessageHandler = (params: {
   accountId: string;
@@ -49,6 +41,14 @@ export type MessageHandler = (params: {
   cfg: ClawdbotConfig;
 }) => Promise<void>;
 
+export type MonitorDingtalkAccountOpts = {
+  cfg: ClawdbotConfig;
+  account: ResolvedDingtalkAccount;
+  runtime?: RuntimeEnv;
+  abortSignal?: AbortSignal;
+  messageHandler: MessageHandler;
+};
+
 // ============ 连接配置 ============
 
 /** 心跳间隔（毫秒） */
@@ -272,7 +272,7 @@ export async function monitorSingleAccount(
       logger.info(`✅ 重连成功 (socket 状态=${client.socket?.readyState})`);
     } catch (err: any) {
       reconnectAttempts++;
-      log?.error?.(
+      logger.error(
         `重连失败：${err.message} (尝试 ${reconnectAttempts})`,
       );
       throw err;
@@ -298,7 +298,7 @@ export async function monitorSingleAccount(
           if (!isStopped && !isReconnecting) {
             // 立即重连，不退避
             doReconnect(true).catch((err) => {
-              log?.error?.(`[${accountId}] 重连失败：${err.message}`);
+              logger.error(`[${accountId}] 重连失败：${err.message}`);
             });
           }
         }
@@ -322,7 +322,7 @@ export async function monitorSingleAccount(
       // 立即重连，不退避
       setTimeout(() => {
         doReconnect(true).catch((err) => {
-          log?.error?.(`重连失败：${err.message}`);
+          logger.error(`重连失败：${err.message}`);
         });
       }, 0);
     });
@@ -388,11 +388,11 @@ export async function monitorSingleAccount(
           lastSocketAvailableTime = Date.now();
           logger.debug(`💓 发送 PING 心跳成功`);
         } catch (err: any) {
-          log?.warn?.(`发送 PING 失败：${err.message}`);
+          logger.warn(`发送 PING 失败：${err.message}`);
           // 发送失败也计入超时
         }
       } catch (err: any) {
-        log?.error?.(`keepAlive 检测失败：${err.message}`);
+        logger.error(`keepAlive 检测失败：${err.message}`);
       }
     }, HEARTBEAT_INTERVAL); // 每 10 秒检测一次
 
@@ -445,7 +445,7 @@ export async function monitorSingleAccount(
             await client.disconnect();
           }
         } catch (err: any) {
-          log?.warn?.(`断开连接时出错：${err.message}`);
+          logger.warn(`断开连接时出错：${err.message}`);
         }
         resolve();
       };
@@ -486,12 +486,13 @@ export async function monitorSingleAccount(
         client.socketCallBackResponse(messageId, { success: true });
         logger.info(`✅ 已立即确认回调：messageId=${messageId}`);
       } else {
-        log?.warn?.(`⚠️ 警告：消息没有 messageId`);
+        logger.warn(`⚠️ 警告：消息没有 messageId`);
       }
 
       // 消息去重
       if (messageId && isMessageProcessed(messageId)) {
-        log?.warn?.(`⚠️ 检测到重复消息，跳过处理：messageId=${messageId}`);
+        processedCount++;  // ✅ 修复：重复消息也要计入 processedCount
+        logger.warn(`⚠️ 检测到重复消息，跳过处理：messageId=${messageId} (${processedCount}/${receivedCount})`);
         logger.info(`========== 消息处理结束（重复） ==========\n`);
         return;
       }
@@ -579,13 +580,9 @@ export async function monitorSingleAccount(
         const errorMsg = `❌ 处理消息异常 (${processedCount}/${receivedCount}): ${error?.message || "未知错误"}`;
         const errorStack = error?.stack || "无堆栈信息";
         
-        // 使用 logger 确保错误信息一定会被打印
-        logger.info(errorMsg);
-        logger.info(`错误堆栈:\n${errorStack}`);
-        
-        // 同时使用 log?.error 记录（如果可用）
-        log?.error?.(errorMsg);
-        log?.error?.(`错误堆栈:\n${errorStack}`);
+        // 使用 logger 记录错误信息
+        logger.error(errorMsg);
+        logger.error(`错误堆栈:\n${errorStack}`);
         
         logger.info(`========== 消息处理结束（失败） ==========\n`);
       } finally {
@@ -672,7 +669,7 @@ export async function monitorSingleAccount(
     // client.on('close', ...) - 已移除，使用 setupCloseListener
 
     client.on("error", (err: Error) => {
-      log?.error?.(`Connection error: ${err.message}`);
+      logger.error(`Connection error: ${err.message}`);
     });
 
     // 监听重连事件（仅用于日志，实际重连由自定义逻辑处理）

package/src/core/message-handler.ts

@@ -44,6 +44,7 @@ import { sendProactive, type AICardTarget } from "../services/messaging/index.ts
 import { createDingtalkReplyDispatcher, normalizeSlashCommand } from "../reply-dispatcher.ts";
 import { getDingtalkRuntime } from "../runtime.ts";
 import { dingtalkHttp } from '../utils/http-client.ts';
+import { createLoggerFromConfig } from '../utils/logger.ts';
 import * as fs from 'fs';
 import * as path from 'path';
 import * as os from 'os';
@@ -537,7 +538,10 @@ interface HandleMessageParams {
  * 内部消息处理函数（实际执行消息处理逻辑）
  */
 export async function handleDingTalkMessageInternal(params: HandleMessageParams): Promise<void> {
-  const { accountId, config, data, sessionWebhook, runtime, log, cfg } = params;
+  const { accountId, config, data, sessionWebhook, runtime, log: inputLog, cfg } = params;
+
+  // 如果传入的 log 为空，则使用基于 config 的 logger
+  const log = createLoggerFromConfig(config, `DingTalk:${accountId}`);
 
   const content = extractMessageContent(data);
   if (!content.text && content.imageUrls.length === 0 && content.downloadCodes.length === 0) return;
@@ -546,32 +550,7 @@ export async function handleDingTalkMessageInternal(params: HandleMessageParams)
   const senderId = data.senderStaffId || data.senderId;
   const senderName = data.senderNick || 'Unknown';
 
-  // ===== 提前解析 agentId 和工作空间路径 =====
-  const chatType = isDirect ? "direct" : "group";
-  const peerId = isDirect ? senderId : data.conversationId;
-  
-  // 手动匹配 bindings 获取 agentId
-  let matchedAgentId: string | null = null;
-  if (cfg.bindings && cfg.bindings.length > 0) {
-    for (const binding of cfg.bindings) {
-      const match = binding.match;
-      if (match.channel && match.channel !== "dingtalk-connector") continue;
-      if (match.accountId && match.accountId !== 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.defaultAgent || 'main';
-  }
-  
-  // 获取 Agent 工作空间路径
-  const agentWorkspaceDir = resolveAgentWorkspaceDir(cfg, matchedAgentId);
-  log?.info?.(`Agent 工作空间路径: ${agentWorkspaceDir}`);
+
 
 
 
@@ -716,6 +695,29 @@ export async function handleDingTalkMessageInternal(params: HandleMessageParams)
     sharedMemoryAcrossConversations: config.sharedMemoryAcrossConversations,
   });
 
+  // ===== 解析 agentId 和工作空间路径（在 sessionContext 之后，确保 peerId 与会话隔离策略一致）=====
+  // 使用 sessionContext.peerId 进行匹配，与后续 sessionKey 构建保持一致，避免两次匹配结果不一致
+  let matchedAgentId: string | null = null;
+  if (cfg.bindings && cfg.bindings.length > 0) {
+    for (const binding of cfg.bindings) {
+      const match = binding.match;
+      if (match.channel && match.channel !== "dingtalk-connector") continue;
+      if (match.accountId && match.accountId !== accountId) continue;
+      if (match.peer) {
+        if (match.peer.kind && match.peer.kind !== sessionContext.chatType) continue;
+        if (match.peer.id && match.peer.id !== '*' && match.peer.id !== sessionContext.peerId) continue;
+      }
+      matchedAgentId = binding.agentId;
+      break;
+    }
+  }
+  if (!matchedAgentId) {
+    matchedAgentId = cfg.defaultAgent || 'main';
+  }
+
+  // 获取 Agent 工作空间路径
+  const agentWorkspaceDir = resolveAgentWorkspaceDir(cfg, matchedAgentId);
+  log?.info?.(`Agent 工作空间路径: ${agentWorkspaceDir}`);
 
   // 构建消息内容
   // ✅ 使用 normalizeSlashCommand 归一化新会话命令
@@ -940,65 +942,24 @@ export async function handleDingTalkMessageInternal(params: HandleMessageParams)
       body: finalContent,
     });
 
-    // 手动实现路由匹配（支持通配符 *）
-    const chatType = isDirect ? "direct" : "group";
-    const peerId = isDirect ? senderId : data.conversationId;
-    
-    // 手动匹配 bindings（支持通配符 *）
-    let matchedAgentId: string | null = null;
-    let matchedBy = 'default';
-    
-    if (cfg.bindings && cfg.bindings.length > 0) {
-      for (const binding of cfg.bindings) {
-        const match = binding.match;
-        
-        // 检查 channel
-        if (match.channel && match.channel !== "dingtalk-connector") {
-          continue;
-        }
-        
-        // 检查 accountId
-        if (match.accountId && match.accountId !== accountId) {
-          continue;
-        }
-        
-        // 检查 peer
-        if (match.peer) {
-          // 检查 peer.kind
-          if (match.peer.kind && match.peer.kind !== sessionContext.chatType) {
-            continue;
-          }
-          
-          // ✅ 使用 sessionContext.peerId 进行匹配（支持通配符 *）
-          if (match.peer.id && match.peer.id !== '*' && match.peer.id !== sessionContext.peerId) {
-            continue;
-          }
-        }
-        
-        // 匹配成功
-        matchedAgentId = binding.agentId;
-        matchedBy = 'binding';
-        break;
-      }
-    }
-    
-    // 如果没有匹配到，使用默认 agent
-    if (!matchedAgentId) {
-      matchedAgentId = cfg.defaultAgent || 'main';
-      log?.info?.(`未匹配到 binding，使用默认 agent: ${matchedAgentId}`);
-    }
+    // matchedAgentId 已在 sessionContext 构建之后通过 bindings 匹配确定，此处直接使用
+    const matchedBy = matchedAgentId !== (cfg.defaultAgent || 'main') ? 'binding' : 'default';
     
     // ✅ 使用 SDK 标准方法构建 sessionKey，符合 OpenClaw 规范
     // 格式：agent:{agentId}:{channel}:{peerKind}:{peerId}
     // ✅ 修复：使用 sessionContext.peerId，确保会话隔离配置生效
+    // ✅ 关键修复：传递 dmScope 参数，让 SDK 使用配置文件中的 session.dmScope 设置
+    const dmScope = cfg.session?.dmScope || 'per-channel-peer';
+    log?.info?.(`🔍 构建 sessionKey 前的参数: agentId=${matchedAgentId}, channel=dingtalk-connector, accountId=${accountId}, chatType=${sessionContext.chatType}, peerId=${sessionContext.peerId}, dmScope=${dmScope}`);
     const sessionKey = core.channel.routing.buildAgentSessionKey({
       agentId: matchedAgentId,
-      channel: 'dingtalk',  // ✅ 使用 'dingtalk' 而不是 'dingtalk-connector'
+      channel: 'dingtalk-connector',  // ✅ 使用 'dingtalk-connector' 而不是 'dingtalk'
       accountId: accountId,
       peer: {
         kind: sessionContext.chatType,  // ✅ 使用 sessionContext.chatType
         id: sessionContext.peerId,      // ✅ 使用 sessionContext.peerId（包含会话隔离逻辑）
       },
+      dmScope: dmScope,  // ✅ 传递 dmScope 参数，确保生成完整格式的 sessionKey
     });
     log?.info?.(`路由解析完成: agentId=${matchedAgentId}, sessionKey=${sessionKey}, matchedBy=${matchedBy}`);
     
@@ -1018,7 +979,7 @@ export async function handleDingTalkMessageInternal(params: HandleMessageParams)
       To: toField,  // ✅ 修复：单聊用 senderId，群聊用 conversationId
       SessionKey: sessionKey,  // ✅ 使用手动匹配的 sessionKey
       AccountId: accountId,
-      ChatType: chatType,
+      ChatType: sessionContext.chatType,
       GroupSubject: isDirect ? undefined : data.conversationId,
       SenderName: senderId,
       SenderId: senderId,
@@ -1201,23 +1162,33 @@ export async function handleDingTalkMessageInternal(params: HandleMessageParams)
  * 确保同一会话+agent的消息按顺序处理，避免并发冲突
  */
 export async function handleDingTalkMessage(params: HandleMessageParams): Promise<void> {
-  const { accountId, data, log, cfg } = params;
+  const { accountId, config, data, log, cfg } = params;
 
-  // 构建会话标识（与会话上下文保持一致）
+  // 使用 buildSessionContext 构建会话标识，与 handleDingTalkMessageInternal 保持一致
+  // 确保 queueKey 的隔离策略（groupSessionScope、sharedMemoryAcrossConversations）与 sessionKey 一致
   const isDirect = data.conversationType === '1';
   const senderId = data.senderStaffId || data.senderId;
   const conversationId = data.conversationId;
-  const baseSessionId = isDirect ? senderId : conversationId;
+
+  const queueSessionContext = buildSessionContext({
+    accountId,
+    senderId,
+    conversationType: data.conversationType,
+    conversationId,
+    separateSessionByConversation: config.separateSessionByConversation,
+    groupSessionScope: config.groupSessionScope,
+    sharedMemoryAcrossConversations: config.sharedMemoryAcrossConversations,
+  });
+
+  const baseSessionId = queueSessionContext.peerId;
 
   if (!baseSessionId) {
     log?.warn?.('无法构建会话标识，跳过队列管理');
     return handleDingTalkMessageInternal(params);
   }
-  
-  // 解析 agentId（与消息处理逻辑保持一致）
-  const chatType = isDirect ? "direct" : "group";
-  const peerId = isDirect ? senderId : conversationId;
 
+  // 解析 agentId：使用 sessionContext.peerId 和 sessionContext.chatType 进行匹配
+  // 与 handleDingTalkMessageInternal 中的匹配逻辑保持一致
   let matchedAgentId: string | null = null;
   if (cfg.bindings && cfg.bindings.length > 0) {
     for (const binding of cfg.bindings) {
@@ -1225,8 +1196,8 @@ export async function handleDingTalkMessage(params: HandleMessageParams): Promis
       if (match.channel && match.channel !== "dingtalk-connector") continue;
       if (match.accountId && match.accountId !== 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;
+        if (match.peer.kind && match.peer.kind !== queueSessionContext.chatType) continue;
+        if (match.peer.id && match.peer.id !== '*' && match.peer.id !== queueSessionContext.peerId) continue;
       }
       matchedAgentId = binding.agentId;
       break;
@@ -1235,9 +1206,11 @@ export async function handleDingTalkMessage(params: HandleMessageParams): Promis
   if (!matchedAgentId) {
     matchedAgentId = cfg.defaultAgent || 'main';
   }
-  
-  // 构建队列标识：会话 + agentId
-  // 这样不同 agent 可以并发处理，同一 agent 的同一会话串行处理
+
+  // 构建队列标识：会话 peerId + agentId
+  // queueKey 与 sessionKey 使用相同的 peerId，确保隔离策略一致：
+  // - groupSessionScope: 'group_sender' 时，同群不同用户的消息可并行处理
+  // - sharedMemoryAcrossConversations: true 时，所有消息共享同一队列
   const queueKey = `${baseSessionId}:${matchedAgentId}`;
 
   try {

package/src/core/provider.ts

@@ -13,6 +13,7 @@
  */
 import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
 import * as monitorState from "./state";
+import { createLogger } from "../utils/logger";
 
 // 只解构 monitorState 的导出
 const {
@@ -44,7 +45,7 @@ export async function monitorDingtalkProvider(opts: MonitorDingtalkOpts = {}): P
     throw new Error("Config is required for DingTalk monitor");
   }
 
-  const log = opts.runtime?.log;
+  const log = createLogger(cfg.channels?.["dingtalk-connector"]?.debug ?? false);
 
   // 并行导入所有模块（无循环依赖，可以并行）
   const [accountsModule, monitorAccountModule, monitorSingleModule] = await Promise.all([

package/src/onboarding.ts

@@ -112,7 +112,7 @@ async function noteDingtalkCredentialHelp(prompter: WizardPrompter): Promise<voi
     [
       "1) Go to DingTalk Open Platform (open-dev.dingtalk.com)",
       "2) Create an enterprise internal app",
-      "3) Get App Key (Client ID) and App Secret (Client Secret) from Credentials page",
+      "3) Get Client ID and Client Secret from Credentials page",
       "4) Enable required permissions: im:message, im:chat",
       "5) Publish the app or add it to a test group",
       "Tip: you can also set DINGTALK_CLIENT_ID / DINGTALK_CLIENT_SECRET env vars.",
@@ -128,7 +128,7 @@ async function promptDingtalkClientId(params: {
 }): Promise<string> {
   const clientId = String(
     await params.prompter.text({
-      message: "Enter DingTalk App Key (Client ID)",
+      message: "Enter DingTalk Client ID",
       initialValue: params.initialValue,
       validate: (value) => (value?.trim() ? undefined : "Required"),
     }),
@@ -274,36 +274,96 @@ export const dingtalkOnboardingAdapter: ChannelOnboardingAdapter = {
       await noteDingtalkCredentialHelp(prompter);
     }
 
-    const clientSecretResult = await promptSingleChannelSecretInput({
-      cfg: next,
-      prompter,
-      providerHint: "dingtalk",
-      credentialLabel: "App Secret (Client Secret)",
-      accountConfigured: Boolean(resolved),
-      canUseEnv,
-      hasConfigToken: hasConfigSecret,
-      envPrompt: "DINGTALK_CLIENT_ID + DINGTALK_CLIENT_SECRET detected. Use env vars?",
-      keepPrompt: "DingTalk App Secret already configured. Keep it?",
-      inputPrompt: "Enter DingTalk App Secret (Client Secret)",
-      preferredEnvVar: "DINGTALK_CLIENT_SECRET",
-    });
-
-    if (clientSecretResult.action === "use-env") {
-      next = {
-        ...next,
-        channels: {
-          ...next.channels,
-          "dingtalk-connector": { ...next.channels?.["dingtalk-connector"], enabled: true },
-        },
-      };
-    } else if (clientSecretResult.action === "set") {
-      clientSecret = clientSecretResult.value;
-      clientSecretProbeValue = clientSecretResult.resolvedValue;
-      clientId = await promptDingtalkClientId({
-        prompter,
-        initialValue:
-          normalizeString(dingtalkCfg?.clientId) ?? normalizeString(process.env.DINGTALK_CLIENT_ID),
+    // Check if we can use environment variables
+    if (canUseEnv) {
+      const useEnv = await prompter.confirm({
+        message: "DINGTALK_CLIENT_ID + DINGTALK_CLIENT_SECRET detected. Use env vars?",
+        initialValue: true,
       });
+
+      if (useEnv) {
+        next = {
+          ...next,
+          channels: {
+            ...next.channels,
+            "dingtalk-connector": { ...next.channels?.["dingtalk-connector"], enabled: true },
+          },
+        };
+        // Environment variables will be used, skip manual input
+      } else {
+        // User chose not to use env vars, proceed to manual input
+        canUseEnv = false;
+      }
+    }
+
+    // If not using env vars, prompt for credentials
+    if (!canUseEnv) {
+      // Check if we should keep existing configuration
+      if (resolved && hasConfigSecret) {
+        const keepExisting = await prompter.confirm({
+          message: "DingTalk credentials already configured. Keep them?",
+          initialValue: true,
+        });
+
+        if (!keepExisting) {
+          // User wants to reconfigure, proceed to input
+          // Step 1: Prompt for Client ID first
+          clientId = await promptDingtalkClientId({
+            prompter,
+            initialValue:
+              normalizeString(dingtalkCfg?.clientId) ?? normalizeString(process.env.DINGTALK_CLIENT_ID),
+          });
+
+          // Step 2: Then prompt for Client Secret
+          const clientSecretResult = await promptSingleChannelSecretInput({
+            cfg: next,
+            prompter,
+            providerHint: "dingtalk",
+            credentialLabel: "Client Secret",
+            accountConfigured: false, // Force new input
+            canUseEnv: false, // Already handled above
+            hasConfigToken: false, // Force new input
+            envPrompt: "", // Not used
+            keepPrompt: "", // Not used
+            inputPrompt: "Enter DingTalk Client Secret",
+            preferredEnvVar: "DINGTALK_CLIENT_SECRET",
+          });
+
+          if (clientSecretResult.action === "set") {
+            clientSecret = clientSecretResult.value;
+            clientSecretProbeValue = clientSecretResult.resolvedValue;
+          }
+        }
+        // If keepExisting is true, we don't modify anything
+      } else {
+        // No existing config, prompt for new credentials
+        // Step 1: Prompt for Client ID first
+        clientId = await promptDingtalkClientId({
+          prompter,
+          initialValue:
+            normalizeString(dingtalkCfg?.clientId) ?? normalizeString(process.env.DINGTALK_CLIENT_ID),
+        });
+
+        // Step 2: Then prompt for Client Secret
+        const clientSecretResult = await promptSingleChannelSecretInput({
+          cfg: next,
+          prompter,
+          providerHint: "dingtalk",
+          credentialLabel: "Client Secret",
+          accountConfigured: false,
+          canUseEnv: false,
+          hasConfigToken: false,
+          envPrompt: "",
+          keepPrompt: "",
+          inputPrompt: "Enter DingTalk Client Secret",
+          preferredEnvVar: "DINGTALK_CLIENT_SECRET",
+        });
+
+        if (clientSecretResult.action === "set") {
+          clientSecret = clientSecretResult.value;
+          clientSecretProbeValue = clientSecretResult.resolvedValue;
+        }
+      }
     }
 
     if (clientId && clientSecret) {

package/src/services/messaging.ts

@@ -858,8 +858,8 @@ async function sendProactiveInternal(
 
   const {
     msgType = "text",
-    useAICard = false,
-    fallbackToNormal = false,
+    useAICard = true,          // 默认启用 AI Card，让主动发送消息优先使用卡片形式
+    fallbackToNormal = true,   // 默认降级，AI Card 失败时自动回退到普通消息
     log: externalLog,
   } = options;
 

package/src/utils/logger.ts

@@ -69,10 +69,10 @@ export function createLogger(debug: boolean = false, prefix: string = '') {
 
 /**
  * 从配置中创建日志记录器
- * @param config - 包含 debug 配置的对象
+ * @param config - 包含 debug 配置的对象（可选）
  * @param prefix - 日志前缀
  * @returns 日志记录器对象
  */
-export function createLoggerFromConfig(config: { debug?: boolean }, prefix: string = '') {
-  return createLogger(!!config.debug, prefix);
+export function createLoggerFromConfig(config: { debug?: boolean } | undefined | null, prefix: string = '') {
+  return createLogger(!!config?.debug, prefix);
 }

package/src/utils/session.ts

@@ -49,7 +49,6 @@ export function buildSessionContext(params: {
   const isDirect = conversationType === '1';
 
   // sharedMemoryAcrossConversations=true 时，所有会话共享记忆
-  // 通过将 peerId 设置为 accountId 来实现跨会话记忆共享
   if (sharedMemoryAcrossConversations === true) {
     return {
       channel: 'dingtalk-connector',
@@ -62,17 +61,20 @@ export function buildSessionContext(params: {
     };
   }
 
+  // separateSessionByConversation=false 时，不区分单聊/群聊，按用户维度维护 session
   if (separateSessionByConversation === false) {
     return {
       channel: 'dingtalk-connector',
       accountId,
       chatType: isDirect ? 'direct' : 'group',
-      peerId: senderId,
+      peerId: senderId, // 只用 senderId，不区分会话
       senderName,
     };
   }
 
+  // 以下是 separateSessionByConversation=true（默认）的逻辑
   if (isDirect) {
+    // 单聊：peerId 为发送者 ID，由 OpenClaw Gateway 根据 dmScope 配置处理
     return {
       channel: 'dingtalk-connector',
       accountId,
@@ -82,7 +84,9 @@ export function buildSessionContext(params: {
     };
   }
 
+  // 群聊：根据 groupSessionScope 配置决定会话隔离策略
   if (groupSessionScope === 'group_sender') {
+    // 群内每个用户独立会话
     return {
       channel: 'dingtalk-connector',
       accountId,
@@ -94,6 +98,7 @@ export function buildSessionContext(params: {
     };
   }
 
+  // 默认：整个群共享一个会话
   return {
     channel: 'dingtalk-connector',
     accountId,

package/src/utils/utils-legacy.ts

@@ -4,6 +4,10 @@
 
 import type { DingtalkConfig, ResolvedDingtalkAccount } from '../types/index.ts';
 
+// SessionContext 和 buildSessionContext 统一由 session.ts 维护
+export type { SessionContext } from './session.ts';
+export { buildSessionContext } from './session.ts';
+
 // ============ 常量 ============
 
 /** 默认账号 ID，用于标记单账号模式（无 accounts 配置）时的内部标识 */
@@ -18,107 +22,6 @@ export const DINGTALK_OAPI = 'https://oapi.dingtalk.com';
 
 // ============ 会话管理 ============
 
-/** OpenClaw 标准会话上下文 */
-export interface SessionContext {
-  channel: 'dingtalk-connector';
-  accountId: string;
-  chatType: 'direct' | 'group';
-  peerId: string;
-  conversationId?: string;
-  senderName?: string;
-  groupSubject?: string;
-}
-
-/**
- * 构建 OpenClaw 标准会话上下文
- * 遵循 OpenClaw session.dmScope 机制，让 Gateway 根据配置自动处理会话隔离
- */
-export function buildSessionContext(params: {
-  accountId: string;
-  senderId: string;
-  senderName?: string;
-  conversationType: string;
-  conversationId?: string;
-  groupSubject?: string;
-  separateSessionByConversation?: boolean;
-  groupSessionScope?: 'group' | 'group_sender';
-  sharedMemoryAcrossConversations?: boolean;
-}): SessionContext {
-  const {
-    accountId,
-    senderId,
-    senderName,
-    conversationType,
-    conversationId,
-    groupSubject,
-    separateSessionByConversation,
-    groupSessionScope,
-    sharedMemoryAcrossConversations,
-  } = params;
-  const isDirect = conversationType === '1';
-
-  // sharedMemoryAcrossConversations=true 时，所有会话共享记忆
-  if (sharedMemoryAcrossConversations === true) {
-    return {
-      channel: 'dingtalk-connector',
-      accountId,
-      chatType: isDirect ? 'direct' : 'group',
-      peerId: accountId, // 使用 accountId 作为 peerId，实现跨会话记忆共享
-      conversationId: isDirect ? undefined : conversationId,
-      senderName,
-      groupSubject: isDirect ? undefined : groupSubject,
-    };
-  }
-
-  // separateSessionByConversation=false 时，不区分单聊/群聊，按用户维度维护 session
-  if (separateSessionByConversation === false) {
-    return {
-      channel: 'dingtalk-connector',
-      accountId,
-      chatType: isDirect ? 'direct' : 'group',
-      peerId: senderId, // 只用 senderId，不区分会话
-      senderName,
-    };
-  }
-
-  // 以下是 separateSessionByConversation=true（默认）的逻辑
-  if (isDirect) {
-    // 单聊：peerId 为发送者 ID，由 OpenClaw Gateway 根据 dmScope 配置处理
-    return {
-      channel: 'dingtalk-connector',
-      accountId,
-      chatType: 'direct',
-      peerId: senderId,
-      senderName,
-    };
-  }
-
-  // 群聊：根据 groupSessionScope 配置决定会话隔离策略
-  if (groupSessionScope === 'group_sender') {
-    // 群内每个用户独立会话
-    return {
-      channel: 'dingtalk-connector',
-      accountId,
-      chatType: 'group',
-      peerId: `${conversationId}:${senderId}`,
-      conversationId,
-      senderName,
-      groupSubject,
-    };
-  }
-
-  // 默认：整个群共享一个会话
-  return {
-    channel: 'dingtalk-connector',
-    accountId,
-    chatType: 'group',
-    peerId: conversationId || senderId,
-    conversationId,
-    senderName,
-    groupSubject,
-  };
-}
-
 /**
  * 检查消息是否是新会话命令
  */

package/test-dingtalk-connection.mjs

@@ -1,105 +0,0 @@
-#!/usr/bin/env node
-
-/**
- * 钉钉连接测试脚本
- * 用于诊断 "HTTP request sent to HTTPS port" 问题
- */
-
-import axios from 'axios';
-import https from 'https';
-import http from 'http';
-
-console.log('='.repeat(60));
-console.log('钉钉连接诊断测试');
-console.log('='.repeat(60));
-console.log('');
-
-// 1. 检查环境变量
-console.log('1. 环境变量检查');
-console.log('---');
-console.log(`HTTP_PROXY: ${process.env.HTTP_PROXY || '未设置'}`);
-console.log(`HTTPS_PROXY: ${process.env.HTTPS_PROXY || '未设置'}`);
-console.log(`http_proxy: ${process.env.http_proxy || '未设置'}`);
-console.log(`https_proxy: ${process.env.https_proxy || '未设置'}`);
-console.log(`NO_PROXY: ${process.env.NO_PROXY || '未设置'}`);
-console.log('');
-
-// 2. 检查 Node.js 版本
-console.log('2. Node.js 版本');
-console.log('---');
-console.log(`Node.js: ${process.version}`);
-console.log('');
-
-// 3. 测试 axios 默认配置
-console.log('3. axios 默认配置');
-console.log('---');
-console.log(`axios.defaults.proxy: ${JSON.stringify(axios.defaults.proxy || '未设置')}`);
-console.log(`axios.defaults.httpAgent: ${axios.defaults.httpAgent ? '已设置' : '未设置'}`);
-console.log(`axios.defaults.httpsAgent: ${axios.defaults.httpsAgent ? '已设置' : '未设置'}`);
-console.log('');
-
-// 4. 测试直接请求钉钉 API
-console.log('4. 测试钉钉 Gateway API');
-console.log('---');
-
-const GATEWAY_URL = 'https://api.dingtalk.com/v1.0/gateway/connections/open';
-
-try {
-  console.log(`请求 URL: ${GATEWAY_URL}`);
-  console.log('发送 POST 请求...');
-  
-  const response = await axios({
-    url: GATEWAY_URL,
-    method: 'POST',
-    responseType: 'json',
-    data: {
-      clientId: 'test',
-      clientSecret: 'test',
-      ua: 'test',
-      subscriptions: [{ type: 'EVENT', topic: '*' }]
-    },
-    headers: {
-      'Accept': 'application/json'
-    },
-    // 显式设置 HTTPS agent
-    httpsAgent: new https.Agent({
-      rejectUnauthorized: true
-    }),
-    // 确保不使用 HTTP agent
-    httpAgent: undefined,
-    // 禁用代理
-    proxy: false,
-    timeout: 10000
-  });
-  
-  console.log(`✅ 请求成功！`);
-  console.log(`状态码: ${response.status}`);
-  console.log(`响应数据: ${JSON.stringify(response.data).substring(0, 200)}...`);
-} catch (error) {
-  console.log(`❌ 请求失败！`);
-  console.log(`错误类型: ${error.constructor.name}`);
-  console.log(`错误消息: ${error.message}`);
-  
-  if (error.response) {
-    console.log(`响应状态码: ${error.response.status}`);
-    console.log(`响应数据: ${typeof error.response.data === 'string' ? error.response.data.substring(0, 500) : JSON.stringify(error.response.data)}`);
-  }
-  
-  if (error.code) {
-    console.log(`错误代码: ${error.code}`);
-  }
-  
-  if (error.config) {
-    console.log(`请求配置:`);
-    console.log(`  - URL: ${error.config.url}`);
-    console.log(`  - Method: ${error.config.method}`);
-    console.log(`  - Proxy: ${JSON.stringify(error.config.proxy)}`);
-    console.log(`  - httpAgent: ${error.config.httpAgent ? '已设置' : '未设置'}`);
-    console.log(`  - httpsAgent: ${error.config.httpsAgent ? '已设置' : '未设置'}`);
-  }
-}
-
-console.log('');
-console.log('='.repeat(60));
-console.log('诊断完成');
-console.log('='.repeat(60));