evolclaw 2.0.7 → 2.1.1

package/dist/core/message-processor.js

@@ -18,6 +18,16 @@ export class MessageProcessor {
     channels = new Map();
     currentFlusher;
     currentIsGroup = false;
+    shouldSuppressActivities = false;
+    /** 判断是否为后台会话（仅主会话参与判断，话题会话独立） */
+    async isBackgroundSession(session, channel, channelId) {
+        // 话题会话独立运行，不是后台任务
+        if (session.threadId)
+            return false;
+        // 主会话：与当前活跃会话比对
+        const active = await this.sessionManager.getActiveSession(channel, channelId);
+        return active ? session.id !== active.id : false;
+    }
     constructor(agentRunner, sessionManager, config, messageCache, commandHandler) {
         this.agentRunner = agentRunner;
         this.sessionManager = sessionManager;
@@ -35,7 +45,7 @@ export class MessageProcessor {
      * 处理 compact 开始事件
      */
     handleCompactStart() {
-        if (this.currentFlusher && !this.currentIsGroup) {
+        if (this.currentFlusher && !this.currentIsGroup && !this.shouldSuppressActivities) {
             this.currentFlusher.addActivity('⏳ 会话压缩中...');
         }
     }
@@ -45,7 +55,7 @@ export class MessageProcessor {
     async processMessage(message) {
         const isGroup = message.isGroup ?? false;
         this.currentIsGroup = isGroup;
-        const idleMs = this.config.idleMonitor?.timeout ?? 120000;
+        const idleMs = (this.config.idleMonitor?.timeout ?? 120) * 1000;
         const streamKey = `${message.channel}-${message.channelId}`;
         const channelInfo = this.channels.get(message.channel);
         const monitorEnabled = this.config.idleMonitor?.enabled !== false;
@@ -53,6 +63,20 @@ export class MessageProcessor {
         const isOwnerUser = isOwner(this.config, message.channel, message.userId || '');
         // 非主人（群聊或单聊）：空闲监控静默/简短
         const quietMode = isGroup || !isOwnerUser;
+        // 计算是否抑制中间输出（工具活动 + 流式文本）
+        const shouldSuppress = () => {
+            const mode = this.config.showActivities ?? 'all';
+            if (mode === 'all')
+                return false;
+            if (mode === 'dm-only')
+                return isGroup;
+            if (mode === 'owner-dm-only')
+                return isGroup || !isOwnerUser;
+            if (mode === 'none')
+                return true;
+            return false;
+        };
+        this.shouldSuppressActivities = shouldSuppress();
         let monitor;
         let monitorInterval;
         let rejectFn;
@@ -94,7 +118,7 @@ export class MessageProcessor {
                     else {
                         // notify or warn: send diagnostic message, task continues（非主人时静默）
                         logger.info(`[MessageProcessor] Idle monitor: ${result.action} after ${result.idleSec}s idle, stream: ${streamKey}`);
-                        if (channelInfo && !quietMode) {
+                        if (channelInfo && !quietMode && !shouldSuppress()) {
                             try {
                                 await channelInfo.adapter.sendText(message.channelId, result.message);
                             }
@@ -109,7 +133,7 @@ export class MessageProcessor {
         });
         try {
             await Promise.race([
-                this._processMessageInternal(message, resetTimer, isGroup),
+                this._processMessageInternal(message, resetTimer, isGroup, shouldSuppress),
                 timeoutPromise
             ]);
         }
@@ -119,7 +143,7 @@ export class MessageProcessor {
             // 记录错误到健康状态（仅主人的错误累计触发安全模式）
             if (channelInfo) {
                 try {
-                    const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd());
+                    const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId);
                     const errorType = classifyError(error);
                     // 上下文过长是可恢复错误，不累计触发安全模式
                     if (errorType === ErrorType.CONTEXT_TOO_LONG) {
@@ -131,7 +155,7 @@ export class MessageProcessor {
                     }
                     else {
                         const newCount = await this.sessionManager.recordError(session.id, errorType, error.message);
-                        await this.checkSafeMode(session.id, message.channelId, channelInfo.adapter, safeModeThreshold, newCount);
+                        await this.checkSafeMode(session, message.channelId, channelInfo.adapter, safeModeThreshold, newCount);
                     }
                 }
                 catch (statusError) {
@@ -145,17 +169,27 @@ export class MessageProcessor {
                 clearInterval(monitorInterval);
         }
     }
+    /** 从 session 提取话题回复选项 */
+    getThreadSendOpts(session) {
+        const rootId = session.metadata?.feishu?.rootId;
+        return rootId ? { replyToMessageId: rootId, replyInThread: true } : undefined;
+    }
     /**
      * 检查是否需要进入安全模式（safeModeThreshold 为 0 时跳过）
      * 仅单聊主人会话调用（群聊和非主人已在调用侧过滤）
      */
-    async checkSafeMode(sessionId, channelId, adapter, safeModeThreshold, consecutiveErrors) {
+    async checkSafeMode(session, channelId, adapter, safeModeThreshold, consecutiveErrors) {
         if (safeModeThreshold <= 0)
             return;
-        const health = await this.sessionManager.getHealthStatus(sessionId);
+        const health = await this.sessionManager.getHealthStatus(session.id);
+        const sendOpts = this.getThreadSendOpts(session);
+        const isThread = !!session.threadId;
         if (consecutiveErrors >= safeModeThreshold && !health.safeMode) {
-            await this.sessionManager.setSafeMode(sessionId, true);
-            logger.warn(`[MessageProcessor] Session ${sessionId} entered safe mode after ${consecutiveErrors} errors`);
+            await this.sessionManager.setSafeMode(session.id, true);
+            logger.warn(`[MessageProcessor] Session ${session.id} entered safe mode after ${consecutiveErrors} errors`);
+            const suggestions = isThread
+                ? `1. /repair - 检查并修复会话（推荐，保留历史）\n2. /clear - 清空会话历史\n3. /status - 查看详细状态`
+                : `1. /repair - 检查并修复会话（推荐，保留历史）\n2. /new [名称] - 创建新会话（清空历史）\n3. /status - 查看详细状态`;
             await adapter.sendText(channelId, `⚠️ 安全模式已启用（连续 ${consecutiveErrors} 次异常）
 
 当前限制：
@@ -163,16 +197,13 @@ export class MessageProcessor {
 - 每次提问需要提供完整上下文
 
 建议操作：
-1. /repair - 检查并修复会话（推荐，保留历史）
-2. /new [名称] - 创建新会话（清空历史）
-3. /status - 查看详细状态`);
+${suggestions}`, sendOpts);
         }
         else if (safeModeThreshold >= 2 && consecutiveErrors === safeModeThreshold - 1) {
-            // 阈值前一次错误，发送警告
-            await adapter.sendText(channelId, `⚠️ 检测到异常（${consecutiveErrors}/${safeModeThreshold}）\n\n如果问题持续，系统将自动进入安全模式。建议使用 /status 查看状态。`);
+            await adapter.sendText(channelId, `⚠️ 检测到异常（${consecutiveErrors}/${safeModeThreshold}）\n\n如果问题持续，系统将自动进入安全模式。建议使用 /status 查看状态。`, sendOpts);
         }
     }
-    async _processMessageInternal(message, resetTimer, isGroup) {
+    async _processMessageInternal(message, resetTimer, isGroup, shouldSuppress) {
         const messageId = `${message.channel}_${message.channelId}_${message.timestamp || Date.now()}`;
         const channelInfo = this.channels.get(message.channel);
         if (!channelInfo) {
@@ -183,17 +214,19 @@ export class MessageProcessor {
         try {
             // 检查是否为命令
             if (this.commandHandler) {
-                const cmdResult = await this.commandHandler(message.content, message.channel, message.channelId, message.userId);
+                const cmdResult = await this.commandHandler(message.content, message.channel, message.channelId, message.userId, message.threadId);
                 if (cmdResult) {
-                    await adapter.sendText(message.channelId, cmdResult);
+                    // 话题消息：通过 rootId 回复到话题内
+                    const session = message.threadId ? await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId) : undefined;
+                    const rootId = session?.metadata?.feishu?.rootId;
+                    const sendOpts = rootId ? { replyToMessageId: rootId, replyInThread: true } : undefined;
+                    await adapter.sendText(message.channelId, cmdResult, sendOpts);
                     return;
                 }
             }
             // 解析会话和项目路径
             const { session, absoluteProjectPath } = await this.resolveSession(message);
-            // 判断是否是后台任务
-            const activeSession = await this.sessionManager.getActiveSession(message.channel, message.channelId);
-            const isBackground = activeSession ? session.id !== activeSession.id : false;
+            const isBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
             // 记录收到消息
             logger.message({
                 msgId: messageId,
@@ -217,43 +250,47 @@ export class MessageProcessor {
             let firstReply = true;
             const messageIsGroup = isGroup; // 捕获 isGroup 供闭包使用
             const flusher = new StreamFlusher(async (text, isFinal) => {
-                // 动态判断是否是后台任务
-                const currentActiveSession = await this.sessionManager.getActiveSession(message.channel, message.channelId);
-                const isCurrentlyBackground = currentActiveSession ? session.id !== currentActiveSession.id : false;
+                const isCurrentlyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
                 if (!isCurrentlyBackground) {
                     const opts = {};
                     if (isFinal)
                         opts.title = '最终回复:';
-                    // 首条消息引用回复用户原消息
-                    if (firstReply && message.messageId) {
+                    // 话题会话：所有回复指向 rootId + reply_in_thread（确保消息进入话题）
+                    const rootId = session.metadata?.feishu?.rootId;
+                    if (rootId) {
+                        opts.replyToMessageId = rootId;
+                        opts.replyInThread = true;
+                    }
+                    else if (firstReply && message.messageId) {
+                        // 主会话：首条消息引用回复用户原消息
                         opts.replyToMessageId = message.messageId;
                         firstReply = false;
                     }
                     await adapter.sendText(message.channelId, text, Object.keys(opts).length ? opts : undefined);
                 }
                 // 后台任务：静默，不发送输出
-            }, this.config.flushDelay ?? 4000, options?.fileMarkerPattern);
+            }, (this.config.flushDelay || 4) * 1000, options?.fileMarkerPattern, this.config.debug?.flusherDiag);
             // 保存当前 flusher，用于 compact 事件
             this.currentFlusher = flusher;
             // 调用 AgentRunner（含上下文过长自动 compact 重试）
             const streamKey = `${message.channel}-${message.channelId}`;
             try {
-                const stream = await this.agentRunner.runQuery(session.id, message.content, absoluteProjectPath, session.claudeSessionId, message.images, options?.systemPromptAppend, this.sessionManager);
+                const stream = await this.agentRunner.runQuery(session.id, message.content, absoluteProjectPath, session.agentSessionId, message.images, options?.systemPromptAppend, this.sessionManager);
                 this.agentRunner.registerStream(streamKey, stream);
-                await this.processEventStream(stream, session, message.channelId, adapter, options, flusher, isBackground, resetTimer);
+                await this.processEventStream(stream, session, message.channelId, adapter, options, flusher, isBackground, resetTimer, shouldSuppress);
             }
             catch (error) {
-                if (classifyError(error) === ErrorType.CONTEXT_TOO_LONG && session.claudeSessionId) {
+                if (classifyError(error) === ErrorType.CONTEXT_TOO_LONG && session.agentSessionId) {
                     // 尝试 compact 压缩会话
                     flusher.addActivity('⚠️ 上下文过长，正在压缩会话...');
                     await flusher.flush();
-                    const compacted = await this.agentRunner.compactSession(session.id, session.claudeSessionId, absoluteProjectPath);
+                    const compacted = await this.agentRunner.compactSession(session.id, session.agentSessionId, absoluteProjectPath);
                     if (compacted) {
                         // compact 成功，带 resume 重试
                         flusher.addActivity('✅ 压缩完成，正在重试...');
-                        const retryStream = await this.agentRunner.runQuery(session.id, message.content, absoluteProjectPath, session.claudeSessionId, message.images, options?.systemPromptAppend, this.sessionManager);
+                        const retryStream = await this.agentRunner.runQuery(session.id, message.content, absoluteProjectPath, session.agentSessionId, message.images, options?.systemPromptAppend, this.sessionManager);
                         this.agentRunner.registerStream(streamKey, retryStream);
-                        await this.processEventStream(retryStream, session, message.channelId, adapter, options, flusher, isBackground, resetTimer);
+                        await this.processEventStream(retryStream, session, message.channelId, adapter, options, flusher, isBackground, resetTimer, shouldSuppress);
                     }
                     else {
                         throw new Error('CONTEXT_COMPACT_FAILED');
@@ -278,7 +315,7 @@ export class MessageProcessor {
                     // 文件存在性检查：真实路径但文件不存在，告知用户
                     if (!fs.existsSync(resolvedPath)) {
                         logger.warn(`[${adapter.name}] File not found: ${resolvedPath}`);
-                        await adapter.sendText(message.channelId, `⚠️ 文件未找到: ${filePath}`);
+                        await adapter.sendText(message.channelId, `⚠️ 文件未找到: ${filePath}`, this.getThreadSendOpts(session));
                         continue;
                     }
                     logger.info(`[${adapter.name}] Sending file: ${resolvedPath}`);
@@ -287,7 +324,7 @@ export class MessageProcessor {
                     }
                     catch (error) {
                         logger.error(`[${adapter.name}] Failed to send file: ${resolvedPath}`, error);
-                        await adapter.sendText(message.channelId, `❌ 文件发送失败: ${filePath}`);
+                        await adapter.sendText(message.channelId, `❌ 文件发送失败: ${filePath}`, this.getThreadSendOpts(session));
                     }
                 }
             }
@@ -296,15 +333,16 @@ export class MessageProcessor {
             // 安全模式尾部提示：如果当前会话处于安全模式，追加提醒
             const healthStatus = await this.sessionManager.getHealthStatus(session.id);
             if (healthStatus.safeMode) {
-                await adapter.sendText(message.channelId, '\n\n⚠️ 当前处于安全模式（无上下文记忆）。使用 /repair 修复 或 /new 新建会话');
+                const hint = session.threadId
+                    ? '\n\n⚠️ 当前处于安全模式（无上下文记忆）。使用 /repair 修复 或 /clear 清空会话'
+                    : '\n\n⚠️ 当前处于安全模式（无上下文记忆）。使用 /repair 修复 或 /new 新建会话';
+                await adapter.sendText(message.channelId, hint, this.getThreadSendOpts(session));
             }
             // 清理 activeStreams（正常完成）
             this.agentRunner.cleanupStream(streamKey);
             // 记录成功响应（重置错误计数）
             await this.sessionManager.recordSuccess(session.id);
-            // 动态判断是否是后台任务，决定是否发送通知
-            const currentActive = await this.sessionManager.getActiveSession(message.channel, message.channelId);
-            const isFinallyBackground = currentActive ? session.id !== currentActive.id : false;
+            const isFinallyBackground = await this.isBackgroundSession(session, message.channel, message.channelId);
             if (isFinallyBackground) {
                 const projectName = path.basename(session.projectPath);
                 const count = this.messageCache.getCount(session.id);
@@ -346,7 +384,14 @@ export class MessageProcessor {
             }
             else {
                 const userMessage = getErrorMessage(error);
-                await adapter.sendText(message.channelId, userMessage);
+                // 获取 session 用于话题回复（如果 resolveSession 已执行）
+                let sendOpts;
+                try {
+                    const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId);
+                    sendOpts = this.getThreadSendOpts(session);
+                }
+                catch { }
+                await adapter.sendText(message.channelId, userMessage, sendOpts);
             }
         }
     }
@@ -354,7 +399,11 @@ export class MessageProcessor {
      * 解析会话和项目路径
      */
     async resolveSession(message) {
-        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd());
+        // 话题会话：传入 rootId metadata（首条消息的 messageId 作为 rootId）
+        const metadata = message.threadId && message.messageId
+            ? { feishu: { rootId: message.messageId } }
+            : undefined;
+        const session = await this.sessionManager.getOrCreateSession(message.channel, message.channelId, this.config.projects?.defaultPath || process.cwd(), message.threadId, metadata);
         const absoluteProjectPath = path.isAbsolute(session.projectPath)
             ? session.projectPath
             : path.resolve(process.cwd(), session.projectPath);
@@ -363,7 +412,7 @@ export class MessageProcessor {
     /**
      * 处理事件流
      */
-    async processEventStream(stream, session, channelId, adapter, options, flusher, isBackground, resetTimer) {
+    async processEventStream(stream, session, channelId, adapter, options, flusher, isBackground, resetTimer, shouldSuppress) {
         let hasTextDelta = false;
         let hasReceivedText = false;
         let lastSessionId;
@@ -382,20 +431,20 @@ export class MessageProcessor {
                     this.agentRunner.updateSessionId(session.id, event.session_id);
                     lastSessionId = event.session_id;
                 }
-                // 动态判断当前是否是后台任务
-                const currentActive = await this.sessionManager.getActiveSession(session.channel, session.channelId);
-                const isCurrentlyBackground = currentActive ? session.id !== currentActive.id : false;
+                const isCurrentlyBackground = await this.isBackgroundSession(session, session.channel, session.channelId);
                 // === 前台任务：正常处理所有事件 ===
                 if (!isCurrentlyBackground) {
-                    // 流式文本事件
+                    // 流式文本事件（抑制时跳过，只累积到 allText）
                     if (event.type === 'text_delta' && event.text) {
                         hasTextDelta = true;
                         hasReceivedText = true;
-                        flusher.addText(event.text);
+                        if (!shouldSuppress()) {
+                            flusher.addText(event.text);
+                        }
                     }
                     // 系统事件：compact_boundary（群聊时静默）
                     if (event.type === 'system' && event.subtype === 'compact_boundary') {
-                        if (!this.currentIsGroup) {
+                        if (!this.currentIsGroup && !shouldSuppress()) {
                             const preTokens = event.compact_metadata?.pre_tokens || 0;
                             flusher.addActivity(`💡 会话压缩完成，继续执行...（压缩前 tokens: ${preTokens}）`);
                         }
@@ -406,10 +455,10 @@ export class MessageProcessor {
                         const duration = event.duration_ms ? `${Math.round(event.duration_ms / 1000)}s` : '';
                         const summary = event.summary;
                         const stats = [tools > 0 ? `${tools}次工具调用` : '', duration].filter(Boolean).join(', ');
-                        if (summary) {
+                        if (summary && !shouldSuppress()) {
                             flusher.addActivity(`⏳ 子任务: ${summary}${stats ? ` (${stats})` : ''}`);
                         }
-                        else if (stats) {
+                        else if (stats && !shouldSuppress()) {
                             flusher.addActivity(`⏳ 子任务进行中: ${stats}`);
                         }
                     }
@@ -417,33 +466,42 @@ export class MessageProcessor {
                     if (event.type === 'assistant' && event.message?.content) {
                         for (const content of event.message.content) {
                             if (content.type === 'tool_use') {
-                                const desc = this.formatToolDescription(content);
-                                flusher.addActivity(`🔧 ${content.name}${desc ? ': ' + desc : ''}`);
+                                if (!shouldSuppress()) {
+                                    const desc = this.formatToolDescription(content);
+                                    flusher.addActivity(`🔧 ${content.name}${desc ? ': ' + desc : ''}`);
+                                }
                             }
                             else if (content.type === 'text' && content.text && !hasTextDelta) {
                                 // 仅在没有 text_delta 事件时从 assistant 事件提取文本，避免重复
                                 hasReceivedText = true;
-                                flusher.addTextBlock(content.text);
+                                if (!shouldSuppress()) {
+                                    flusher.addTextBlock(content.text);
+                                }
                             }
                         }
                     }
                     // 工具结果事件：显示失败信息（包括权限拒绝、执行失败等所有场景）
                     if (event.type === 'tool_result') {
                         logger.debug(`[MessageProcessor] tool_result: is_error=${event.is_error}, error=${event.error}, content=${typeof event.content}`);
-                        if (event.is_error) {
+                        if (event.is_error && !shouldSuppress()) {
                             const toolName = event.tool_name || '工具';
                             const errorMsg = event.error || (typeof event.content === 'string' ? event.content : JSON.stringify(event.content)) || '执行失败';
                             flusher.addActivity(`⚠️ ${toolName}: ${errorMsg}`);
                         }
                     }
-                    // Result 事件：仅在没有流式文本时使用 result 作为最终输出
+                    // Result 事件：最终输出
                     if (event.type === 'result' && event.result) {
-                        logger.debug(`[MessageProcessor] result event: hasReceivedText=${hasReceivedText}, result="${event.result}"`);
-                        if (!hasReceivedText) {
-                            // 没有通过 text_delta 或 assistant 收到文本，使用 result 作为兜底
+                        logger.debug(`[MessageProcessor] result event: hasReceivedText=${hasReceivedText}, shouldSuppress=${shouldSuppress()}, result="${event.result}"`);
+                        if (shouldSuppress()) {
+                            // 抑制模式：直接发送 result（跳过中间输出）
+                            flusher.addText(event.result);
+                        }
+                        else if (!hasReceivedText) {
+                            // 非抑制模式 + 无流式文本：使用 result 作为兜底
                             flusher.addText(event.result);
                         }
-                        await flusher.flush();
+                        // 非抑制模式 + 有流式文本：已通过 text_delta 累积，无需再添加
+                        await flusher.flush(true); // isFinal=true 标记最终输出
                     }
                     continue;
                 }