claw-subagent-service 0.0.176 → 0.0.179

package/package.json

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

package/service/modules/rongyun-message-handler.js

@@ -78,12 +78,72 @@ class RongyunMessageHandler {
     this.commandLock = false;
     this.commandLockTimer = null;
     this.messageSender = null;
+    this.serverAPI = null;
+    // 流式消息队列：确保片段串行发送
+    this._streamQueue = Promise.resolve();
+    // 存储流式消息的 RongCloud messageUID：streamId -> messageUID
+    this._streamMessageUIDs = new Map();
   }
 
   setMessageSender(messageSender) {
     this.messageSender = messageSender;
   }
 
+  setServerAPI(serverAPI) {
+    this.serverAPI = serverAPI;
+  }
+
+  /**
+   * 发送流式消息片段（直接调用融云 API）
+   * @param {string} fromUserId - 发送者ID
+   * @param {string} targetId - 目标用户ID
+   * @param {string} content - 消息内容
+   * @param {string} streamId - 流式消息ID
+   * @param {boolean} isFirstChunk - 是否首流
+   * @param {boolean} isLastChunk - 是否尾流
+   * @param {number} seq - 片段序号
+   */
+  async _sendStreamChunk(fromUserId, targetId, content, streamId, isFirstChunk, isLastChunk, seq = 1) {
+    const contentPreview = typeof content === 'string' ? content.substring(0, 100) : JSON.stringify(content).substring(0, 100);
+    this.logInfo(`[RongyunMessageHandler] _sendStreamChunk: target=${targetId}, streamId=${streamId}, seq=${seq}, first=${isFirstChunk}, last=${isLastChunk}, content_len=${content?.length || 0}`);
+    
+    if (!this.serverAPI) {
+      this.logWarn('[RongyunMessageHandler] _sendStreamChunk skipped: serverAPI not configured');
+      return;
+    }
+    
+    // 使用队列确保流式消息片段串行发送，避免并发导致后端处理错乱
+    this._streamQueue = this._streamQueue.then(async () => {
+      try {
+        // 获取已存储的 RongCloud messageUID（首流响应返回的）
+        const messageUID = this._streamMessageUIDs.get(streamId);
+        
+        const result = await this.serverAPI.sendStreamPrivate({
+          fromUserId,
+          toUserId: targetId,
+          content,
+          streamId,
+          isFirstChunk,
+          isLastChunk,
+          seq,
+          messageUID
+        });
+        
+        // 首流时存储 RongCloud 返回的 messageUID
+        if (isFirstChunk && result?.messageUID) {
+          this._streamMessageUIDs.set(streamId, result.messageUID);
+          this.logInfo(`[RongyunMessageHandler] 首流 messageUID 已存储: ${result.messageUID}, streamId=${streamId}`);
+        }
+        
+        this.logInfo(`[RongyunMessageHandler] _sendStreamChunk 成功: seq=${seq}`);
+      } catch (err) {
+        this.logWarn(`[RongyunMessageHandler] 发送流式消息失败: ${err.message}, seq=${seq}`);
+      }
+    });
+    
+    await this._streamQueue;
+  }
+
   logInfo(message) {
     if (this.log?.info) {
       this.log.info(message);
@@ -285,7 +345,7 @@ class RongyunMessageHandler {
     const roomId = data.room_id;
     const sessionId = data.gateway_session_id || data.session_id;
     // 使用解析后的 content（聊天内容），如果没有则使用原始 content
-    const content = data.content || data._raw_content;
+    let content = data.content || data._raw_content;
     const requestId = data.request_id;
     const sourceId = data.source_im_id;
 
@@ -301,12 +361,43 @@ class RongyunMessageHandler {
       return;
     }
 
+    // 语音消息：先进行语音识别
+    if (data.voiceUrl) {
+      const voiceText = await this._recognizeVoice(data.voiceUrl, data.voiceDuration);
+      if (voiceText !== null) {
+        content = `[语音转文字] ${voiceText}`;
+      } else {
+        content = `[语音消息，转文字失败] ${content}`;
+      }
+    }
+
     let fullResponse = '';
+    let buffer = ''; // 用于流式发送的缓冲区
     const chatTimeoutMs = (this.config.chatTimeout || 600) * 1000;
+    
+    // 生成流式消息唯一ID
+    const streamId = `stream-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+    let seq = 0;
+    let hasSentChunk = false;
+    const fromUserId = this.config.accountId || '';
 
     try {
       await forwardChatMessage(sessionId, content, async (delta) => {
         fullResponse += delta;
+        buffer += delta;
+        
+        // 当缓冲区达到一定大小或包含标点时，发送流式片段
+        // 使用 50 字符作为触发阈值（与 message-handler.js 保持一致）
+        if (buffer.length >= 50) {
+          seq += 1;
+          const chunkToSend = buffer;
+          buffer = ''; // 清空缓冲区
+          
+          // 首流时发送首流标记
+          const isFirstChunk = seq === 1;
+          await this._sendStreamChunk(fromUserId, sourceId, chunkToSend, streamId, isFirstChunk, false, seq);
+          hasSentChunk = true;
+        }
       }, (level, message) => {
         if (level === 'ERROR') {
           this.logError(`[CHAT-API] ${message}`);
@@ -317,21 +408,50 @@ class RongyunMessageHandler {
         }
       }, chatTimeoutMs);
 
+      // 发送剩余缓冲区内容
+      if (buffer.length > 0) {
+        seq += 1;
+        const isFirstChunk = seq === 1;
+        await this._sendStreamChunk(fromUserId, sourceId, buffer, streamId, isFirstChunk, false, seq);
+        hasSentChunk = true;
+        buffer = '';
+      }
+
+      // 发送尾流标记
+      if (hasSentChunk) {
+        seq += 1;
+        await this._sendStreamChunk(fromUserId, sourceId, '', streamId, false, true, seq);
+      }
+
+      // 同时发送完整的 command 消息作为历史记录（兼容旧前端）
       await this.sendResponse(RongyunMessageTypeEnum.CHAT_MESSAGE, {
         status: 'success',
         message: 'Response received',
         content: fullResponse,
         metadata: {}
       }, requestId, sourceId);
+      
+      // 清理已存储的 messageUID
+      this._streamMessageUIDs.delete(streamId);
     } catch (e) {
       const msg = e instanceof Error ? e.message : String(e);
       this.logError(`聊天消息处理异常: ${msg}`);
+      
+      // 如果已经开始流式发送，发送错误标记
+      if (hasSentChunk) {
+        seq += 1;
+        await this._sendStreamChunk(fromUserId, sourceId, `[错误] 转发失败: ${msg}`, streamId, false, true, seq);
+      }
+      
       await this.sendResponse(RongyunMessageTypeEnum.CHAT_MESSAGE, {
         status: 'error',
         message: msg,
         content: `[错误] 转发失败: ${msg}`,
         metadata: {}
       }, requestId, sourceId);
+      
+      // 清理已存储的 messageUID
+      this._streamMessageUIDs.delete(streamId);
     }
   }
 
@@ -766,6 +886,53 @@ class RongyunMessageHandler {
       this.logError(`发送响应失败: ${msg}`);
     }
   }
+
+  /**
+   * 语音识别：调用后端百度语音 API 将语音转为文字
+   */
+  async _recognizeVoice(voiceUrl, voiceDuration) {
+    try {
+      if (!voiceUrl) {
+        this.logWarn('[_recognizeVoice] 语音 URL 为空，跳过识别');
+        return null;
+      }
+
+      // 从 URL 提取扩展名并映射为百度支持的格式
+      const urlPath = voiceUrl.split('?')[0];
+      const ext = urlPath.split('.').pop()?.toLowerCase() || '';
+      const fmtMap = { aac: 'm4a', ogg: 'mp3', oga: 'mp3', opus: 'mp3' };
+      let format = fmtMap[ext] || ext;
+      if (!['pcm', 'wav', 'amr', 'm4a', 'mp3'].includes(format)) {
+        format = 'mp3';
+      }
+
+      // 采样率修正：amr 强制 8000，其余兜底 16000
+      let sampleRate = 16000;
+      if (format === 'amr') sampleRate = 8000;
+
+      const axios = require('axios');
+      const apiUrl = `${this.config.apiBaseUrl}/im/api/voice/recognize`;
+      this.logInfo(`[_recognizeVoice] 调用语音识别 API: ${apiUrl}, format=${format}, sampleRate=${sampleRate}`);
+
+      const response = await axios.post(apiUrl, {
+        audioUrl: voiceUrl,
+        format,
+        sampleRate,
+      }, { timeout: 30000 });
+
+      if (response.data?.code === 200 && response.data?.data?.text !== undefined) {
+        const text = response.data.data.text;
+        this.logInfo(`[_recognizeVoice] 语音识别成功: "${text.substring(0, 50)}${text.length > 50 ? '...' : ''}"`);
+        return text;
+      } else {
+        this.logWarn(`[_recognizeVoice] 语音识别失败: ${JSON.stringify(response.data)}`);
+        return null;
+      }
+    } catch (err) {
+      this.logError(`[_recognizeVoice] 语音识别异常: ${err.message}`);
+      return null;
+    }
+  }
 }
 
 module.exports = {

package/service/modules/rongyun-message-sender.js

@@ -176,9 +176,9 @@ class RongyunMessageSender {
 
       // 优先使用自定义消息类型发送 P2P 消息
       let result;
-      if (this.rongcloudClient.ServiceChatMessage && msgType.includes('service')) {
-        // 客服相关消息使用 service_chat 自定义消息类型
-        // 对于客服消息，直接将业务内容放在顶层，方便前端解析
+      // 客服消息和聊天消息都将业务内容放在顶层，方便前端解析
+      if (this.rongcloudClient.ServiceChatMessage && (msgType.includes('service') || msgType === 'chat_message')) {
+        // 对于客服/聊天消息，直接将业务内容放在顶层，方便前端解析
         const serviceChatPayload = {
           msg_type: msgType,
           ...content,  // 展开业务内容（status, content, sessionId, userId 等）
@@ -245,6 +245,65 @@ class RongyunMessageSender {
       requestId
     );
   }
+
+  /**
+   * 发送流式消息片段（P2P）
+   * 使用融云服务端API发送 RC:StreamMsg
+   * @param {Object} options - 流式消息选项
+   * @param {string} options.targetId - 目标用户ID
+   * @param {string} options.content - 消息片段内容
+   * @param {string} options.streamId - 流式消息ID
+   * @param {number} options.seq - 片段序号
+   * @param {boolean} options.isFirstChunk - 是否首流
+   * @param {boolean} options.isLastChunk - 是否尾流
+   * @param {string} options.messageUID - 首流返回的messageUID（后续流使用）
+   * @returns {Promise<Object>} 发送结果
+   */
+  async sendStreamToTarget({
+    targetId,
+    content,
+    streamId,
+    seq = 1,
+    isFirstChunk = false,
+    isLastChunk = false,
+    messageUID = null
+  }) {
+    // 需要 serverAPI 支持
+    if (!this.serverAPI) {
+      this.log?.error('[RongyunMessageSender] serverAPI 未设置，无法发送流式消息');
+      return false;
+    }
+
+    try {
+      const fromUserId = this.config.accountId || '';
+      
+      const result = await this.serverAPI.sendStreamPrivate({
+        fromUserId,
+        toUserId: targetId,
+        content,
+        streamId,
+        isFirstChunk,
+        isLastChunk,
+        seq,
+        streamType: 'text',
+        messageUID
+      });
+
+      this.log?.info(`[RongyunMessageSender] 流式消息已发送: seq=${seq}, first=${isFirstChunk}, last=${isLastChunk}`);
+      return result;
+    } catch (err) {
+      this.log?.error(`[RongyunMessageSender] 发送流式消息失败: ${err.message}`);
+      return false;
+    }
+  }
+
+  /**
+   * 设置 serverAPI（用于发送流式消息）
+   * @param {RongCloudServerAPI} serverAPI 
+   */
+  setServerAPI(serverAPI) {
+    this.serverAPI = serverAPI;
+  }
 }
 
 module.exports = {

package/service/worker.js

@@ -8,6 +8,8 @@ const { createLogger } = require('./logger');
 const { RongCloudClient, MessageHandler, ensurePluginsAllow } = require('./rongcloud');
 const { RongyunMessageHandler } = require('./modules/rongyun-message-handler');
 const { RongyunMessageSender } = require('./modules/rongyun-message-sender');
+const { RongCloudServerAPI } = require('./rongcloud/rongcloud-server-api');
+const { SystemConfigManager } = require('./modules/system-config');
 const { HeartbeatManager, DashboardReporter } = require('./modules/heartbeat-dashboard');
 const { getOpenClawStatus } = require('./modules/port-checker');
 const { getMacAddress } = require('./modules/mac-address');
@@ -340,12 +342,20 @@ async function initRongCloud() {
 
   rongcloudClient = new RongCloudClient(rongcloudConfig, log);
 
+  // 创建系统配置管理器（用于融云服务端API）
+  const configManager = new SystemConfigManager(rongcloudConfig, log);
+  
+  // 创建融云服务端API客户端（用于发送流式消息）
+  const serverAPI = new RongCloudServerAPI(configManager, log);
+
   // 创建消息发送器
   const messageSender = new RongyunMessageSender(rongcloudClient, rongcloudConfig, log);
+  messageSender.setServerAPI(serverAPI); // 注入 serverAPI，支持发送流式消息
 
   // 创建新的融云消息处理器（与桌面客户端对齐）
   const rongyunMessageHandler = new RongyunMessageHandler(rongcloudClient, rongcloudConfig, log);
   rongyunMessageHandler.setMessageSender(messageSender);
+  rongyunMessageHandler.setServerAPI(serverAPI); // 注入 serverAPI
 
   messageHandler = new MessageHandler(
     rongcloudConfig,