lightclawbot 1.2.0-beta.0 → 1.2.0-beta.1

package/dist/src/channel.js

@@ -1,313 +1,182 @@
 /**
- * LightClaw — ChannelPlugin 主定义文件
+ * LightClaw — ChannelPlugin 主定义
  *
- * 使用 OpenClaw SDK 标准的 createChatChannelPlugin 构建器创建聊天频道插件，
+ * 使用 SDK 标准的 createChatChannelPlugin 构建器，
+ * 参照官方 Discord/Slack channel 实现。
  *
- * 主要结构组成：
- *   base:     基础配置 - 来自 shared.ts 的 createLightclawPluginBase + 扩展字段
- *   messaging: 消息目标解析 - 处理消息发送目标的标准化和验证
- *   status:   状态管理 - 插件运行状态监控和状态面板构建
- *   gateway:  Gateway 生命周期 - WebSocket 连接管理和账户生命周期
- *   outbound: 出站消息适配器 - 消息发送和媒体文件处理
- *
- * 该插件实现了与 AI 助手服务的 WebSocket 通信、消息收发、状态管理等核心功能。
+ * 结构：
+ *   base:     来自 shared.ts 的 createLightclawPluginBase + 扩展字段
+ *   security: DM 安全策略
+ *   outbound: 出站消息适配器
  */
 import { createChatChannelPlugin } from 'openclaw/plugin-sdk/core';
-// 导入工具函数和常量
 import { chunkText, defaultAccountId } from './utils/index.js';
 import { CHANNEL_KEY, DEFAULT_ACCOUNT_ID, TEXT_CHUNK_LIMIT } from './config.js';
-// 导入功能模块
-import { sendText, sendMedia } from './outbound.js'; // 出站消息发送
-import { startGateway } from './gateway.js'; // WebSocket Gateway 启动
-import { createLightclawPluginBase } from './shared.js'; // 基础插件配置
-import { lightclawSetupAdapter } from './setup-core.js'; // Setup 适配器
-import { normalizeTarget, looksLikeId } from './messaging.js'; // 消息目标处理
-/**
- * LightClaw 主插件实例
- *
- * 使用 createChatChannelPlugin 工厂函数创建类型安全的 ChannelPlugin 实例，
- * 泛型参数 ResolvedAssistantAccount 指定了账户数据的类型结构。
- *
- * @type {ChannelPlugin<ResolvedAssistantAccount>}
- */
+import { sendText, sendMedia } from './outbound.js';
+import { startGateway } from './gateway.js';
+import { createLightclawPluginBase } from './shared.js';
+import { lightclawSetupAdapter } from './setup-core.js';
+import { normalizeTarget, looksLikeId } from './messaging.js';
+// ============================================================
+// ChannelPlugin 定义（使用 createChatChannelPlugin）
+// ============================================================
 export const lightclawPlugin = createChatChannelPlugin({
-    // ==================== 基础配置 ====================
     base: {
         // ---- 来自 shared.ts 的基础定义 ----
-        // 使用扩展运算符合并基础配置和 setup 适配器
         ...createLightclawPluginBase({
-            setup: lightclawSetupAdapter, // Setup 阶段使用的适配器
+            setup: lightclawSetupAdapter,
         }),
-        // ---- 消息目标解析配置 ----
+        // ---- 消息目标解析 ----
         messaging: {
-            /**
-             * 目标标准化函数
-             * 对原始目标字符串进行标准化处理：去除空格、统一格式、转换编码等
-             *
-             * @param {string} target - 原始目标字符串
-             * @returns {string} 标准化后的目标字符串
-             */
+            // 对原始目标字符串进行标准化处理，如去除空格、统一格式、转换编码等，返回标准化后的字符串
             normalizeTarget: (target) => {
                 return normalizeTarget(target);
             },
-            /** 目标解析器配置 */
             targetResolver: {
-                /**
-                 * ID 格式检测函数
-                 * 判断一个原始字符串是否看起来像一个有效的 ID 格式
-                 * 用于在完整解析前快速分流处理逻辑，提高性能
-                 *
-                 * @param {string} id - 待检测的字符串
-                 * @param {string} [normalized] - 可选的标准化的字符串
-                 * @returns {boolean} 是否看起来像 ID 格式
-                 */
+                // 判断一个原始字符串是否看起来像一个 ID，用于在解析前快速分流处理逻辑
                 looksLikeId: (id, normalized) => {
                     return looksLikeId(id, normalized);
                 },
-                /**
-                 * 目标格式提示文本
-                 * 显示在 CLI 帮助信息中，指导用户正确的目标格式
-                 */
+                /** 目标格式提示文本，显示在 CLI 帮助信息中 */
                 hint: `user:<userId> or channel:<groupId>`,
             },
         },
-        // ---- 状态面板配置 ----
+        // ---- 状态面板 ----
         status: {
-            /** 默认运行时状态配置 */
             defaultRuntime: {
-                accountId: DEFAULT_ACCOUNT_ID, // 默认账户ID
-                running: false, // 运行状态：未运行
-                connected: false, // 连接状态：未连接
-                lastConnectedAt: null, // 最后连接时间：null
-                lastError: null, // 最后错误信息：null
+                accountId: DEFAULT_ACCOUNT_ID,
+                running: false,
+                connected: false,
+                lastConnectedAt: null,
+                lastError: null,
             },
-            /**
-             * 构建频道摘要信息
-             * 根据快照数据生成频道级别的状态摘要
-             *
-             * @param {Object} param0 - 参数对象
-             * @param {Object} param0.snapshot - 状态快照数据
-             * @returns {Object} 频道摘要信息
-             */
             buildChannelSummary: ({ snapshot }) => ({
-                configured: snapshot.configured ?? false, // 是否已配置
-                running: snapshot.running ?? false, // 是否正在运行
-                connected: snapshot.connected ?? false, // 是否已连接
-                lastConnectedAt: snapshot.lastConnectedAt ?? null, // 最后连接时间
-                lastError: snapshot.lastError ?? null, // 最后错误信息
+                configured: snapshot.configured ?? false,
+                running: snapshot.running ?? false,
+                connected: snapshot.connected ?? false,
+                lastConnectedAt: snapshot.lastConnectedAt ?? null,
+                lastError: snapshot.lastError ?? null,
             }),
-            /**
-             * 构建账户快照信息
-             * 根据账户、运行时和配置数据生成账户级别的状态快照
-             *
-             * @param {Object} param0 - 参数对象
-             * @param {ResolvedAssistantAccount} param0.account - 账户信息
-             * @param {Object} param0.runtime - 运行时状态
-             * @param {OpenClawConfig} param0.cfg - 配置信息
-             * @returns {Object} 账户快照信息
-             */
             buildAccountSnapshot: ({ account, runtime, cfg }) => ({
-                accountId: account?.accountId ?? defaultAccountId(cfg), // 账户ID，优先使用账户的ID
-                name: account?.name, // 账户名称
-                enabled: account?.enabled ?? false, // 是否启用
-                configured: Boolean(account?.apiKey), // 是否已配置（有API密钥）
-                running: runtime?.running ?? false, // 是否正在运行
-                connected: runtime?.connected ?? false, // 是否已连接
-                lastConnectedAt: runtime?.lastConnectedAt ?? null, // 最后连接时间
-                lastError: runtime?.lastError ?? null, // 最后错误信息
+                accountId: account?.accountId ?? defaultAccountId(cfg),
+                name: account?.name,
+                enabled: account?.enabled ?? false,
+                configured: Boolean(account?.apiKey),
+                running: runtime?.running ?? false,
+                connected: runtime?.connected ?? false,
+                lastConnectedAt: runtime?.lastConnectedAt ?? null,
+                lastError: runtime?.lastError ?? null,
             }),
         },
-        // ---- Gateway 生命周期管理（核心功能） ----
+        // ---- Gateway 生命周期（核心！） ----
         gateway: {
             /**
-             * 启动账户
-             * 建立 WebSocket 长连接到 AI 助手服务器
-             * OpenClaw 框架会在加载配置后为每个启用的账户调用此方法
-             *
-             * @async
-             * @param {Object} ctx - 上下文对象
-             * @param {ResolvedAssistantAccount} ctx.account - 账户信息
-             * @param {AbortSignal} ctx.abortSignal - 中止信号，用于取消操作
-             * @param {Object} ctx.log - 日志记录器
-             * @param {OpenClawConfig} ctx.cfg - 配置信息
-             * @param {Function} ctx.setStatus - 状态设置函数
-             * @param {Function} ctx.getStatus - 状态获取函数
+             * 启动账户：建立 WS 长连接到 AI 助手 Server
+             * OpenClaw 会在加载配置后为每个 enabled 的账户调用此方法
              */
             startAccount: async (ctx) => {
-                const { account, abortSignal, log, cfg, accountId } = ctx;
-                // 记录启动日志
-                log?.info(`[${CHANNEL_KEY}:${accountId}] Starting gateway...`);
+                const { account, abortSignal, log, cfg } = ctx;
+                log?.info(`[${CHANNEL_KEY}:${account.accountId}] Starting gateway...`);
                 // 启动并维持一个 Socket.IO Gateway 实例
                 await startGateway({
-                    account, // 账户信息
-                    abortSignal, // 中止信号
-                    cfg, // 配置信息
-                    log, // 日志记录器
-                    /**
-                     * WebSocket 连接就绪回调
-                     * 当 WebSocket 连接成功建立时调用
-                     */
+                    account,
+                    abortSignal,
+                    cfg,
+                    log,
+                    /** WS 连接就绪回调 */
                     onReady: () => {
-                        log?.info(`[${CHANNEL_KEY}:${accountId}] Gateway ready: WS connected`);
+                        log?.info(`[${CHANNEL_KEY}:${account.accountId}] Gateway ready: WS connected`);
                         const now = Date.now();
-                        // 更新运行时状态
                         ctx.setStatus({
-                            ...ctx.getStatus(), // 保留现有状态
-                            running: true, // 设置为运行中
-                            connected: true, // 设置为已连接
-                            lastConnectedAt: now, // 记录最后连接时间
+                            ...ctx.getStatus(),
+                            running: true,
+                            connected: true,
+                            lastConnectedAt: now,
                             // 连接建立时即设置 lastEventAt，作为 health-monitor stale-socket 检测的初始基准
-                            lastEventAt: now, // 最后事件时间
+                            lastEventAt: now,
                         });
                     },
-                    /**
-                     * WebSocket 连接断开回调
-                     * 当 WebSocket 连接断开时调用
-                     */
+                    /** WS 连接断开回调 */
                     onDisconnect: () => {
-                        log?.info(`[${CHANNEL_KEY}:${accountId}] Gateway ready: WS disconnect`);
-                        // 更新连接状态为断开
+                        log?.info(`[${CHANNEL_KEY}:${account.accountId}] Gateway ready: WS disconnect`);
                         ctx.setStatus({
-                            ...ctx.getStatus(), // 保留现有状态
-                            connected: false, // 设置为未连接
+                            ...ctx.getStatus(),
+                            connected: false,
                         });
                     },
-                    /**
-                     * 错误回调
-                     * 当发生错误时调用，记录错误信息但不中断重连逻辑
-                     * 重连逻辑由 gateway 内部处理
-                     *
-                     * @param {Error} error - 错误对象
-                     */
+                    /** 错误回调：记录错误信息，不中断重连逻辑（由 gateway 内部处理） */
                     onError: (error) => {
-                        log?.error(`[${CHANNEL_KEY}:${accountId}] Gateway error: ${error.message}`);
-                        // 记录错误信息
+                        log?.error(`[${CHANNEL_KEY}:${account.accountId}] Gateway error: ${error.message}`);
                         ctx.setStatus({
-                            ...ctx.getStatus(), // 保留现有状态
-                            lastError: error.message, // 记录错误消息
+                            ...ctx.getStatus(),
+                            lastError: error.message,
                         });
                     },
                     /**
-                     * 入站事件回调
-                     * 每次收到消息时调用，用于：
-                     * - 刷新 lastEventAt 和 lastInboundAt 时间戳
-                     * - 通知框架 health-monitor 该连接仍处于活跃状态
-                     * - 防止因长时间无活动而被判定为僵死连接
+                     * 入站事件回调：每次收到消息时调用。
+                     * 刷新 lastEventAt 和 lastInboundAt，
+                     * 通知框架 health-monitor 该连接仍处于活跃状态。
                      */
                     onEvent: () => {
-                        log?.info(`[${CHANNEL_KEY}:${accountId}] Gateway Ready: WS message enter`);
-                        // 更新事件时间戳
+                        log?.info(`[${CHANNEL_KEY}:${account.accountId}] Gateway Ready: WS message enter`);
                         ctx.setStatus({
-                            ...ctx.getStatus(), // 保留现有状态
-                            lastEventAt: Date.now(), // 最后事件时间
-                            lastInboundAt: Date.now(), // 最后入站消息时间
+                            ...ctx.getStatus(),
+                            lastEventAt: Date.now(),
+                            lastInboundAt: Date.now(),
                         });
                     },
                 });
             },
-            /**
-             * 登出账户
-             * 清除账户的凭证信息（如 API 密钥）
-             *
-             * @async
-             * @param {Object} param0 - 参数对象
-             * @param {string} param0.accountId - 账户ID
-             * @param {OpenClawConfig} param0.cfg - 配置信息
-             * @returns {Promise<{ok: boolean, cleared: boolean}>} 操作结果
-             */
+            /** 登出账户：清除凭证 */
             logoutAccount: async ({ accountId, cfg }) => {
-                // 创建配置副本以避免修改原始配置
                 const nextCfg = { ...cfg };
-                // 获取当前 channel 的配置节
                 const section = nextCfg.channels?.[CHANNEL_KEY];
-                let cleared = false; // 清理标志
+                let cleared = false;
                 if (section) {
-                    // 处理默认账户的 API 密钥
                     if (accountId === DEFAULT_ACCOUNT_ID && section.apiKeys) {
-                        delete section.apiKeys; // 删除默认账户的 API 密钥
-                        cleared = true; // 标记为已清理
+                        delete section.apiKeys;
+                        cleared = true;
                     }
-                    // 处理特定账户的 API 密钥
                     const accounts = section.accounts;
                     if (accounts?.[accountId]?.apiKeys) {
-                        delete accounts[accountId].apiKeys; // 删除指定账户的 API 密钥
-                        cleared = true; // 标记为已清理
+                        delete accounts[accountId].apiKeys;
+                        cleared = true;
                     }
                 }
-                // 返回操作结果
                 return { ok: true, cleared };
             },
         },
     },
-    // ==================== 出站消息适配器 ====================
+    // ---- 出站消息适配器 ----
     outbound: {
-        // 基础出站配置
         base: {
-            deliveryMode: 'direct', // 交付模式：直接交付
-            chunker: chunkText, // 文本分块处理器
-            chunkerMode: 'markdown', // 分块模式：Markdown
-            textChunkLimit: TEXT_CHUNK_LIMIT, // 文本分块限制大小
-            /**
-             * 目标解析函数
-             * 解析消息发送的目标地址
-             *
-             * @param {Object} param0 - 参数对象
-             * @param {string} param0.to - 显式指定的目标
-             * @param {string[]} param0.allowFrom - 允许的来源列表
-             * @param {string} param0.mode - 模式（'direct' 或 'implicit'）
-             * @returns {Object} 解析结果
-             */
+            deliveryMode: 'direct',
+            chunker: chunkText,
+            chunkerMode: 'markdown',
+            textChunkLimit: TEXT_CHUNK_LIMIT,
             resolveTarget: ({ to, allowFrom, mode }) => {
-                // 优先使用显式指定的目标地址
+                // 优先使用显式 to；implicit 模式下回退到 allowFrom 第一个非通配符条目
                 const effectiveTo = to?.trim();
                 if (effectiveTo) {
                     return { ok: true, to: effectiveTo };
                 }
-                // implicit 模式下回退到 allowFrom 第一个非通配符条目
                 if (mode === 'implicit' && allowFrom && allowFrom.length > 0) {
                     const candidate = allowFrom.find((entry) => entry && entry !== '*');
                     if (candidate) {
                         return { ok: true, to: candidate };
                     }
                 }
-                // 没有找到有效目标，返回错误
                 return {
                     ok: false,
                     error: new Error(`No delivery target for ${CHANNEL_KEY}. Specify a target with --to or configure allowFrom.`),
                 };
             },
         },
-        // 附加结果处理
         attachedResults: {
-            channel: CHANNEL_KEY, // 频道标识
-            /**
-             * 发送文本消息
-             *
-             * @async
-             * @param {Object} param0 - 参数对象
-             * @param {string} param0.to - 目标地址
-             * @param {string} param0.text - 文本内容
-             * @param {string} param0.accountId - 账户ID
-             * @param {string} param0.replyToId - 回复消息ID
-             * @param {OpenClawConfig} param0.cfg - 配置信息
-             * @returns {Promise<any>} 发送结果
-             */
+            channel: CHANNEL_KEY,
             sendText: async ({ to, text, accountId, replyToId, cfg }) => {
                 return sendText({ to, text, accountId, replyToId, cfg });
             },
-            /**
-             * 发送媒体消息
-             *
-             * @async
-             * @param {Object} param0 - 参数对象
-             * @param {string} param0.to - 目标地址
-             * @param {string} param0.text - 文本内容
-             * @param {string} param0.mediaUrl - 媒体文件URL
-             * @param {string} param0.accountId - 账户ID
-             * @param {string} param0.replyToId - 回复消息ID
-             * @param {OpenClawConfig} param0.cfg - 配置信息
-             * @returns {Promise<any>} 发送结果
-             */
             sendMedia: async ({ to, text, mediaUrl, accountId, replyToId, cfg }) => {
                 return sendMedia({ to, text, mediaUrl, accountId, replyToId, cfg });
             },

package/dist/src/gateway.js

@@ -130,7 +130,6 @@ export async function startGateway(ctx) {
      * 底层 emit：将 PrivateMessageData 通过 ReliableEmitter 发送给客户端。
      * - 统一对 content 字段执行 formatCosUrls（将内部 COS 路径转换为公网 URL）
      * - 所有消息都走可靠发送队列，入队即视为"发送成功"，实际 ACK 由 ReliableEmitter 保证
-     * - 需求约束：所有出站消息必须携带 agentId。调用方未显式指定时，回退到包装 emitter 绑定的 agentId。
      */
     const emit = (data) => {
         // 完整发送日志由 ReliableEmitter 打印（含 idempotencyKey）
@@ -147,8 +146,7 @@ export async function startGateway(ctx) {
      * @param targetId     - 接收方用户 ID
      * @param text         - 回复文本内容
      * @param replyToMsgId - 可选，回复对应的原始消息 ID（用于前端展示引用关系）
-     * @param agentId      - 可选，指定此条出站消息归属的 Agent ID；
-     *                       缺省时由上层包装 emitter 注入，所有出站消息都将携带 agentId。
+     * @param agentId      - 可选，目标 Agent ID
      */
     const sendReply = (targetId, text, replyToMsgId, agentId) => {
         log?.info(`[${CHANNEL_KEY}] sendReply: ${text} to ${targetId} (replyTo: ${replyToMsgId || 'none'})`);
@@ -170,7 +168,7 @@ export async function startGateway(ctx) {
      * @param text         - 消息文本（可为空字符串）
      * @param files        - 文件附件列表（{name, mimeType, bytes} 格式）
      * @param replyToMsgId - 可选，回复对应的原始消息 ID
-     * @param agentId      - 可选，指定此条出站消息归属的 Agent ID。
+     * @param agentId      - 可选，目标 Agent ID
      */
     const sendFiles = (targetId, text, files, replyToMsgId, agentId) => {
         return emit({
@@ -202,7 +200,7 @@ export async function startGateway(ctx) {
             catch (err) {
                 log?.error(`[${CHANNEL_KEY}] Message handler error: ${err}`);
                 try {
-                    emitter.sendReply(msg.senderId, "消息处理异常，请稍后重试。", msg.messageId, msg.agentId);
+                    emitter.sendReply(msg.senderId, "消息处理异常，请稍后重试。", msg.messageId);
                     emitter.emit({
                         msgId: generateMsgId(),
                         from: emitter.botClientId,
@@ -256,7 +254,7 @@ export async function startGateway(ctx) {
     // 使用原生 WebSocket 封装层建立连接
     const socket = new NativeSocketClient(WS_URL, {
         // 认证：ticket 作为 URL query 参数，替代 Authorization header
-        path: `${SOCKET_PATH}${ticketQuery}`,
+        path: `${SOCKET_PATH}${ticketQuery}&enableMultiLogin=false`,
         // 注入日志对象，便于 NativeSocketClient 内部打印连接/重连/错误等诊断信息
         log,
         logPrefix: `[${CHANNEL_KEY}:${account.accountId}:NativeSocket]`,

package/dist/src/inbound.js

@@ -77,24 +77,7 @@ export function createInboundHandler(account, emitter, log) {
         const targetId = msg.senderId;
         // 2. 提前发 typing_start（作为"已读回执"，减少 COS 下载/LLM TTFT 期间的无反馈感）
         const replyMsgId = generateMsgId();
-        // 将 route.agentId 作为整条消息处理链路的绑定默认值，所有出站消息均携带此 agentId
-        const effectiveAgentId = route.agentId ?? resolvedAgentId ?? DEFAULT_AGENT_ID;
-        // 基于上层 gateway 的 emitter，构造一个绑定当前 agentId 的包装 emitter
-        // 所有调用 emit / sendReply / sendFiles 未显式传 agentId 时，消息体都会自动注入 effectiveAgentId
-        const boundEmitter = {
-            botClientId: emitter.botClientId,
-            agentId: effectiveAgentId,
-            emit: (data) => emitter.emit({ ...data, agentId: data.agentId ?? effectiveAgentId }),
-            sendReply: (tid, text, replyTo, agentId) => emitter.sendReply(tid, text, replyTo, agentId ?? effectiveAgentId),
-            sendFiles: (tid, text, files, replyTo, agentId) => emitter.sendFiles(tid, text, files, replyTo, agentId ?? effectiveAgentId),
-        };
-        const signalCtx = {
-            emitter: boundEmitter,
-            targetId,
-            replyMsgId,
-            originalMsgId: msg.messageId,
-            agentId: effectiveAgentId,
-        };
+        const signalCtx = { emitter, targetId, replyMsgId, originalMsgId: msg.messageId, agentId: resolvedAgentId };
         emitSignal(signalCtx, 'typing_start');
         // 3. 处理文件附件（files[] → 本地存储 + 公网 URL）
         const localMediaPaths = [];
@@ -241,14 +224,13 @@ export function createInboundHandler(account, emitter, log) {
         });
         // 7. 构建流式 dispatcher
         const { dispatcher, replyOptions: streamReplyOptions, hasEmittedContent, } = createStreamReplyConfig({
-            emitter: boundEmitter,
+            emitter,
             targetId,
             replyMsgId,
             originalMsgId: msg.messageId,
             log,
             effectiveApiKey,
             typingAlreadyStarted: true,
-            agentId: effectiveAgentId,
         }, { ...prefixOptions, onModelSelected }, signalCtx);
         // 8. 分发给 AI 引擎（真流式）。abort 由 openclaw fast-abort 处理，sink 层
         //    把英文回执汉化；此处仅兜底自身抛错。
@@ -268,7 +250,7 @@ export function createInboundHandler(account, emitter, log) {
             log?.error(`[${CHANNEL_KEY}] Dispatch error: ${errMsg}`);
             // 已推过可见内容时不再追加错误文案，避免打断阅读。
             if (!hasEmittedContent()) {
-                emitter.sendReply(targetId, '抱歉，处理您的消息时出现了问题，请稍后重试', msg.messageId, effectiveAgentId);
+                emitter.sendReply(targetId, '抱歉，处理您的消息时出现了问题，请稍后重试', msg.messageId);
             }
         }
     };

package/dist/src/outbound.js

@@ -10,7 +10,7 @@
  *      - 连接断开但 entry 存在（重连中）→ 缓冲消息，重连后自动 flush
  *   2. WS 不可用时 fallback 到 REST API（需配置 apiBaseUrl）
  */
-import { CHANNEL_KEY, DEFAULT_ACCOUNT_ID, DEFAULT_AGENT_ID, EVENT_MESSAGE_PRIVATE } from './config.js';
+import { CHANNEL_KEY, DEFAULT_ACCOUNT_ID, EVENT_MESSAGE_PRIVATE } from './config.js';
 import { getLightclawRuntime } from './runtime.js';
 import { getSocket, bufferMessage, hasEntry, getBotClientId, getReliableEmitter } from './socket/index.js';
 import { resolveAccount } from './utils/index.js';
@@ -99,8 +99,6 @@ function sendViaSocket(accountId, target, text, replyToId) {
         timestamp: Date.now(),
         // undefined 表示非回复消息，避免发送多余字段
         replyToMsgId: replyToId ?? undefined,
-        // 所有出站消息必须携带 agentId，outbound 主动发送场景使用默认 Agent
-        agentId: DEFAULT_AGENT_ID,
     };
     if (entry) {
         // 策略 1：Socket 已连接，优先走可靠发送（emitWithAck + 自动重试）

package/dist/src/runtime.js

@@ -1,29 +1,9 @@
 /**
- * LightClaw — 插件运行时存储模块
+ * LightClaw — 插件运行时存储
  *
- * 使用 OpenClaw SDK 标准的 createPluginRuntimeStore 工具函数替代传统的手动单例管理模式，
- *
- * 该模块的主要功能：
- * - 提供类型安全的运行时存储管理
- * - 避免手动单例模式带来的潜在问题
- * - 提供统一的错误处理和初始化状态管理
- * - 支持插件运行时的动态设置和获取
+ * 使用 SDK 标准的 createPluginRuntimeStore 替代手动单例管理，
+ * 确保与官方 channel 插件（Discord/Slack）的模式一致。
  */
-// 导入运行时存储创建工具函数
 import { createPluginRuntimeStore } from 'openclaw/plugin-sdk/runtime-store';
-/**
- * 创建 LightClaw 插件运行时存储
- *
- * 使用 createPluginRuntimeStore 工厂函数创建运行时存储对象，
- * 该函数返回一个包含 setRuntime 和 getRuntime 方法的对象。
- *
- * @template PluginRuntime - 运行时对象的类型参数
- * @param {string} 'LightClaw runtime not initialized' - 运行时未初始化时的错误消息
- * @returns {Object} 包含 setRuntime 和 getRuntime 方法的对象
- * @property {Function} setRuntime - 设置运行时实例的函数
- * @property {Function} getRuntime - 获取运行时实例的函数（如果未设置会抛出错误）
- */
-const { setRuntime: setLightclawRuntime, getRuntime: getLightclawRuntime } = createPluginRuntimeStore('LightClaw runtime not initialized' // 运行时未初始化时的自定义错误消息
-);
-// 导出运行时管理函数，供其他模块使用
+const { setRuntime: setLightclawRuntime, getRuntime: getLightclawRuntime } = createPluginRuntimeStore('LightClaw runtime not initialized');
 export { getLightclawRuntime, setLightclawRuntime };

package/dist/src/socket/handlers.js

@@ -145,7 +145,7 @@ export function bindSocketHandlers(socket, deps) {
                     sessionKey: '',
                     messages: [],
                     error: err instanceof Error ? err.message : String(err),
-                    agentId: data.agentId,
+                    agentId: data.agentId || DEFAULT_AGENT_ID,
                 }, errorMsgId);
             }
         });

package/dist/src/streaming/stream-reply-sink.js

@@ -30,7 +30,7 @@ function localizeAbortReplyText(text) {
     return OPENCLAW_ABORT_REPLY_RE.test(text.trim()) ? LOCALIZED_ABORT_REPLY : text;
 }
 export function createStreamReplyConfig(opts, prefixOptions, signalCtx) {
-    const { emitter, targetId, originalMsgId, log, effectiveApiKey, typingAlreadyStarted, agentId } = opts;
+    const { emitter, targetId, originalMsgId, log, effectiveApiKey, typingAlreadyStarted } = opts;
     // ── 增量追踪 & 已推送文本 ──
     let partialReplyState = createDeltaTrackerState();
     let streamedText = "";
@@ -110,11 +110,11 @@ export function createStreamReplyConfig(opts, prefixOptions, signalCtx) {
             enrichedText = enrichedText ? `${enrichedText}\n\n${urlSection}` : urlSection;
         }
         if (files.length > 0) {
-            emitter.sendFiles(targetId, enrichedText, files, originalMsgId, agentId);
+            emitter.sendFiles(targetId, enrichedText, files, originalMsgId);
             emittedUserVisible = true;
         }
         else if (enrichedText.trim()) {
-            emitter.sendReply(targetId, enrichedText, originalMsgId, agentId);
+            emitter.sendReply(targetId, enrichedText, originalMsgId);
             emittedUserVisible = true;
         }
     };
@@ -256,7 +256,7 @@ export function createStreamReplyConfig(opts, prefixOptions, signalCtx) {
                     : "LLM only produced thinking, no visible text";
                 log?.warn(`[${CHANNEL_KEY}] [stream] NO_REPLY: counts=${JSON.stringify(counts)} ` +
                     `toolStart=${toolStartCount} assistantMsg=${assistantMessageCount}. Cause: ${cause}`);
-                emitter.sendReply(targetId, "NO_REPLY", originalMsgId, agentId);
+                emitter.sendReply(targetId, "NO_REPLY", originalMsgId);
             }
             else {
                 log?.info(`[${CHANNEL_KEY}] [stream] markComplete: counts=${JSON.stringify(counts)} ` +

package/dist/src/types.js

@@ -24,8 +24,7 @@ export function emitSignal(ctx, kind, content = "", extra) {
         timestamp: Date.now(),
         kind,
         ...(kind !== "typing_start" ? { replyToMsgId: originalMsgId } : {}),
-        // 所有出站信号帧统一携带 agentId，优先使用 signalCtx.agentId，否则回退 emitter 绑定值
-        ...(agentId || emitter.agentId ? { agentId: agentId ?? emitter.agentId } : {}),
         ...extra,
+        agentId,
     });
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "lightclawbot",
-  "version": "1.2.0-beta.0",
+  "version": "1.2.0-beta.1",
   "description": "LightClawBot channel plugin with message support, cron jobs, and proactive messaging",
   "type": "module",
   "files": [