claw-subagent-service 0.0.115 → 0.0.117

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claw-subagent-service",
-  "version": "0.0.115",
+  "version": "0.0.117",
   "description": "虾说智能助手",
   "main": "cli.js",
   "bin": {

package/service/rongcloud/message-handler.js

@@ -29,6 +29,10 @@ class MessageHandler {
     this._groupConfigCache = new Map();
     this._defaultMaxRounds = 10;
     this._groupConfigCacheTTL = config.groupConfigCacheTTL || 60000; // 默认缓存 60 秒
+    
+    // 消息合并相关
+    this._pendingMessages = new Map(); // 待合并的消息
+    this._messageMergeTimeout = 500; // 合并等待时间（毫秒）
   }
 
   /**
@@ -215,42 +219,102 @@ class MessageHandler {
         });
       }
 
-      // 如果配置了代理地址，使用流式处理
-      if (this.isStreamingEnabled) {
-        try {
-          await this.handleNormalMessageStream(msg);
-          // 流式处理成功，群聊轮数 +1
-          if (msg.conversationType === 3) {
-            this._incrementGroupRoundCount(msg.targetId, maxRounds);
-          }
-        } catch (err) {
-          this.log?.error(`[MessageHandler] 流式处理失败，回退到非流式: ${err.message}`);
-          const reply = await this.handleNormalMessage(msg);
-          if (reply) {
-            const targetId = this.getReplyTarget(msg);
-            await this.sendFn(targetId, reply, msg.conversationType);
-            // 非流式回退成功，群聊轮数 +1
-            if (msg.conversationType === 3) {
-              this._incrementGroupRoundCount(msg.targetId, maxRounds);
-            }
-          }
+      // 消息合并逻辑：如果是图片消息，等待一段时间看是否有文字消息跟随
+      if (msg.messageType === 'RC:ImgMsg') {
+        await this._handleImageMessageWithMerge(msg, maxRounds);
+        return;
+      }
+
+      // 普通消息直接处理
+      await this._processMessage(msg, maxRounds);
+    } catch (err) {
+      this.log?.error(`[MessageHandler] 处理消息异常: ${err.message}`);
+      const targetId = msg.conversationType === 3 ? msg.targetId : msg.senderUserId;
+      await this.sendFn(targetId, `处理失败: ${err.message}`, msg.conversationType);
+    }
+  }
+
+  /**
+   * 处理图片消息，支持合并后续文字消息
+   */
+  async _handleImageMessageWithMerge(msg, maxRounds) {
+    const userId = msg.senderUserId;
+    const conversationKey = `${msg.conversationType}-${msg.targetId}-${userId}`;
+    
+    // 设置待处理图片消息
+    this._pendingMessages.set(conversationKey, {
+      imageMsg: msg,
+      timestamp: Date.now(),
+    });
+    
+    // 等待一段时间，看是否有文字消息跟随
+    await new Promise(resolve => setTimeout(resolve, this._messageMergeTimeout));
+    
+    // 获取待处理消息
+    const pending = this._pendingMessages.get(conversationKey);
+    this._pendingMessages.delete(conversationKey);
+    
+    if (!pending) {
+      return; // 消息已被处理
+    }
+    
+    // 构建合并后的消息内容
+    const imageContent = this._extractMessageContent(pending.imageMsg);
+    let mergedContent = imageContent;
+    
+    if (pending.textMsg) {
+      const textContent = typeof pending.textMsg.content === 'string' 
+        ? pending.textMsg.content 
+        : (pending.textMsg.content?.content || '');
+      mergedContent = `${textContent}\n${imageContent}`;
+      this.log?.info(`[MessageHandler] 合并消息: 图片+文字`);
+    }
+    
+    // 创建合并后的消息对象
+    const mergedMsg = {
+      ...pending.imageMsg,
+      content: mergedContent,
+      messageType: 'RC:TxtMsg', // 转为文本消息处理
+    };
+    
+    await this._processMessage(mergedMsg, maxRounds);
+  }
+
+  /**
+   * 处理普通消息（包括合并后的消息）
+   */
+  async _processMessage(msg, maxRounds) {
+    // 如果配置了代理地址，使用流式处理
+    if (this.isStreamingEnabled) {
+      try {
+        await this.handleNormalMessageStream(msg);
+        // 流式处理成功，群聊轮数 +1
+        if (msg.conversationType === 3) {
+          this._incrementGroupRoundCount(msg.targetId, maxRounds);
         }
-      } else {
-        // 降级到非流式处理
+      } catch (err) {
+        this.log?.error(`[MessageHandler] 流式处理失败，回退到非流式: ${err.message}`);
         const reply = await this.handleNormalMessage(msg);
         if (reply) {
           const targetId = this.getReplyTarget(msg);
           await this.sendFn(targetId, reply, msg.conversationType);
-          // 非流式处理成功，群聊轮数 +1
+          // 非流式回退成功，群聊轮数 +1
           if (msg.conversationType === 3) {
             this._incrementGroupRoundCount(msg.targetId, maxRounds);
           }
         }
       }
-    } catch (err) {
-      this.log?.error(`[MessageHandler] 处理消息异常: ${err.message}`);
-      const targetId = msg.conversationType === 3 ? msg.targetId : msg.senderUserId;
-      await this.sendFn(targetId, `处理失败: ${err.message}`, msg.conversationType);
+    } else {
+      // 降级到非流式处理
+      const reply = await this.handleNormalMessage(msg);
+      if (reply) {
+        const targetId = this.getReplyTarget(msg);
+        await this.sendFn(targetId, reply, msg.conversationType);
+        // 非流式处理成功，群聊轮数 +1
+        if (msg.conversationType === 3) {
+          this._incrementGroupRoundCount(msg.targetId, maxRounds);
+        }
+      }
     }
   }
 

package/service/rongcloud/openclaw-client.js

@@ -254,9 +254,11 @@ class OpenClawClient {
   // 会话历史管理：为每个用户维护对话上下文
   static conversationHistory = new Map();
   // 最大历史轮数（用户+AI 各算一轮）
-  static maxHistoryRounds = 10;
+  static maxHistoryRounds = 50;
   // 单条消息最大长度（超过则截断）
   static maxMessageLength = 2000;
+  // 活跃请求管理：为每个用户跟踪当前正在进行的请求
+  static activeRequests = new Map();
 
   static async acquireSlot() {
     if (OpenClawClient.runningCount < OpenClawClient.maxConcurrency) {
@@ -414,6 +416,21 @@ class OpenClawClient {
    * @param {Function} onError - 出错时的回调 (error: Error) => void
    * @returns {Promise<void>}
    */
+  /**
+   * 取消用户的活跃请求
+   * @param {string} fromUser - 用户ID
+   */
+  cancelActiveRequest(fromUser) {
+    const activeRequest = OpenClawClient.activeRequests.get(fromUser);
+    if (activeRequest) {
+      this.log?.info(`[OpenClawClient] 取消用户 ${fromUser} 的活跃请求`);
+      activeRequest.abort();
+      OpenClawClient.activeRequests.delete(fromUser);
+      return true;
+    }
+    return false;
+  }
+
   async chatStream(message, fromUser, onDelta, onDone, onError) {
     if (!message || !message.trim()) {
       onError?.(new Error('消息内容为空'));
@@ -428,6 +445,12 @@ class OpenClawClient {
       return;
     }
 
+    // 取消该用户之前的活跃请求（如果存在）
+    const hasCancelled = this.cancelActiveRequest(fromUser);
+    if (hasCancelled) {
+      this.log?.info(`[OpenClawClient] 用户 ${fromUser} 的新消息到达，已取消前一条消息的回复`);
+    }
+
     this.log?.info(`[OpenClawClient] 准备 SSE 流式调用 OpenClaw，from=${fromUser}`);
 
     const gatewayToken = getGatewayToken();
@@ -445,7 +468,7 @@ class OpenClawClient {
     for (let i = 0; i < endpoints.length; i++) {
       const apiUrl = endpoints[i];
       try {
-        const fullText = await this._doChatStream(apiUrl, gatewayToken, sessionId, messagesWithHistory, onDelta, onDone);
+        const fullText = await this._doChatStream(apiUrl, gatewayToken, sessionId, fromUser, messagesWithHistory, onDelta, onDone);
         
         // 成功响应后，保存当前对话到历史记录
         this._addToHistory(fromUser, 'user', message);
@@ -453,6 +476,12 @@ class OpenClawClient {
         
         return; // 成功则直接返回
       } catch (err) {
+        // 检查是否是取消错误
+        if (err.name === 'AbortError' || err.message?.includes('aborted')) {
+          this.log?.info(`[OpenClawClient] 请求被用户取消: ${fromUser}`);
+          return;
+        }
+
         const is404 = err.response?.status === 404;
         const isLast = i === endpoints.length - 1;
 
@@ -531,7 +560,7 @@ class OpenClawClient {
     }
   }
 
-  async _doChatStream(apiUrl, gatewayToken, sessionId, messages, onDelta, onDone) {
+  async _doChatStream(apiUrl, gatewayToken, sessionId, fromUser, messages, onDelta, onDone) {
     const headers = {
       'Content-Type': 'application/json',
       'Accept': 'text/event-stream'
@@ -605,10 +634,17 @@ class OpenClawClient {
     let hasError = false;
     let errorMsg = '';
 
+    // 创建 AbortController 用于取消请求
+    const abortController = new AbortController();
+    
+    // 注册活跃请求
+    OpenClawClient.activeRequests.set(fromUser, abortController);
+
     const response = await axios.post(apiUrl, payload, {
       headers,
       responseType: 'stream',
-      timeout: 600000 // 10 分钟
+      timeout: 600000, // 10 分钟
+      signal: abortController.signal
     });
 
     return new Promise((resolve, reject) => {
@@ -677,6 +713,9 @@ class OpenClawClient {
       });
 
       response.data.on('end', async () => {
+        // 清理活跃请求
+        OpenClawClient.activeRequests.delete(fromUser);
+        
         this.log?.info(`[OpenClawClient] SSE 流结束，总长度: ${fullText.length}`);
 
         if (hasError) {
@@ -706,6 +745,9 @@ class OpenClawClient {
       });
 
       response.data.on('error', (err) => {
+        // 清理活跃请求
+        OpenClawClient.activeRequests.delete(fromUser);
+        
         this.log?.error(`[OpenClawClient] SSE 流错误: ${err.message}`);
         reject(err);
       });