claw-subagent-service 0.0.58 → 0.0.60

package/package.json

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

package/service/modules/config.js

@@ -72,7 +72,8 @@ function loadConfig() {
     openclawPort: localConfig.openclawPort || 18789,
     scriptTimeout: localConfig.scriptTimeout || 180,
     successKeyword: localConfig.successKeyword || 'Success',
-    chatTimeout: localConfig.chatTimeout || 600
+    chatTimeout: localConfig.chatTimeout || 600,
+    apiBaseUrl: process.env.API_BASE_URL || localConfig.apiBaseUrl || clawBridgeConfig.apiBaseUrl || 'http://127.0.0.1:5000'
   };
 }
 

package/service/rongcloud/index.js

@@ -4,8 +4,8 @@ const { OpenClawClient } = require('./openclaw-client');
 const { RongCloudClient, ConversationType } = require('./rongcloud-client');
 const { ensurePluginsAllow } = require('./openclaw-config');
 
-function createRongCloudModule(config, sendFn, log) {
-  return new MessageHandler(config, sendFn, log);
+function createRongCloudModule(config, sendFn, log, sendReadReceiptFn) {
+  return new MessageHandler(config, sendFn, log, sendReadReceiptFn);
 }
 
 module.exports = {

package/service/rongcloud/message-handler.js

@@ -1,172 +1,291 @@
-const { MessageType } = require('./types');
-const { OpenClawClient } = require('./openclaw-client');
-const { handleNormalMessage } = require('../modules/normal-message-handler');
-const MENTION_REGEX = /@(claw_[a-zA-Z0-9]+)/g;
-
-class MessageHandler {
-  constructor(config, sendFn, log, sendReadReceiptFn) {
-    this.config = config;
-    this.sendFn = sendFn;
-    this.log = log;
-    this.sendReadReceiptFn = sendReadReceiptFn;
-    this.openclawClient = new OpenClawClient(log);
-    this.nodeId = config.accountId || '';
-    this.handleNormalMessage = handleNormalMessage;
-  }
-
-  extractMentions(content) {
-    const mentions = [];
-    let match;
-    while ((match = MENTION_REGEX.exec(content)) !== null) {
-      mentions.push(match[1]);
-    }
-    MENTION_REGEX.lastIndex = 0;
-    return mentions;
-  }
-
-  shouldHandleMessage(msg) {
-    // 过滤离线消息：离线消息是历史记录，不需要重复处理
-    if (msg.isOffLineMessage) {
-      this.log?.info('[MessageHandler] 收到离线消息，忽略');
-      return false;
-    }
-
-    const allowedTypes = ['RC:TxtMsg', 'claw'];
-    if (!allowedTypes.includes(msg.messageType)) {
-      this.log?.info(`[MessageHandler] 忽略非文本消息: ${msg.messageType}`);
-      return false;
-    }
-
-    if (msg.senderUserId === this.config.accountId) {
-      this.log?.info('[MessageHandler] 忽略自己发送的消息');
-      return false;
-    }
-
-    // 优先从融云 mentionedInfo 提取被@用户列表（用户界面 @昵称，但融云底层存的是 userId）
-    let mentions = [];
-    if (msg.mentionedInfo && Array.isArray(msg.mentionedInfo.userIdList)) {
-      mentions = msg.mentionedInfo.userIdList;
-      if (mentions.length > 0) {
-        this.log?.info(`[MessageHandler] 融云 mentionedInfo: ${mentions.join(', ')}，本节点: ${this.nodeId}`);
-      }
-    }
-
-    // 兜底：从文本内容中正则匹配 @claw_xxx
-    if (mentions.length === 0) {
-      const textContent = typeof msg.content === 'string' ? msg.content : (msg.content?.content || '');
-      mentions = this.extractMentions(textContent);
-    }
-
-    if (mentions.length > 0) {
-      if (!mentions.includes(this.nodeId)) {
-        this.log?.info(`[MessageHandler] 消息 @${mentions.join(', ')}，非本节点(${this.nodeId})，忽略`);
-        return false;
-      }
-      this.log?.info(`[MessageHandler] 消息提及本节点(${this.nodeId})，处理`);
-    } else if (msg.conversationType === 3) {
-      // 群聊消息未 @ 任何人 → 视为所有人参与，正常处理
-      this.log?.info(`[MessageHandler] 群聊消息未 @ 任何人，本节点(${this.nodeId})参与处理`);
-    } else {
-      this.log?.info(`[MessageHandler] 单聊消息未指定节点，本节点(${this.nodeId})处理`);
-    }
-
-    return true;
-  }
-
-  async handleMessage(msg) {
-    if (!this.shouldHandleMessage(msg)) {
-      return;
-    }
-
-    try {
-      const type = this.getMessageType(msg);
-      const logContent = typeof msg.content === 'string' ? msg.content : (msg.content?.content || '');
-      this.log?.info(`[MessageHandler] 收到消息 from=${msg.senderUserId}, type=${type}, content=${logContent.substring(0, 50)}`);
-      if (msg.messageType === 'claw') {
-        this.log?.info(`收到龙虾消息，交由 OpenClawClient 处理`);
-        await this.handleClaw(msg);
-      } else {
-        const reply = await this.handleNormalMessage(msg);
-        if (reply) {
-          const targetId = this.getReplyTarget(msg);
-          await this.sendFn(targetId, reply, msg.conversationType);
-        }
-      }
-    } 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);
-    }
-  }
-
-  getMessageType(msg) {
-    if (msg.messageType === 'claw') {
-      return MessageType.CLAW;
-    }
-    const text = typeof msg.content === 'string' ? msg.content : (msg.content?.content || '');
-    if (text.startsWith('/')) {
-      return MessageType.COMMAND;
-    }
-    return MessageType.NORMAL;
-  }
-
-  getReplyTarget(msg) {
-    if (msg.conversationType === 3) {
-      return msg.targetId;
-    }
-    return msg.senderUserId;
-  }
-
-  async handleCommand(msg) {
-    const payload = this.parseCommand(msg.content, msg.senderUserId);
-    this.log?.info(`[MessageHandler] 指令消息: command=${payload.command}, args=${payload.args.join(', ')}`);
-
-    let reply;
-    if (this.config.onCommand) {
-      try {
-        reply = await this.config.onCommand(payload);
-      } catch (err) {
-        this.log?.error(`[MessageHandler] 指令处理回调异常: ${err.message}`);
-        reply = `指令执行异常: ${err.message}`;
-      }
-    } else {
-      reply = `指令 "${payload.command}" 暂未实现`;
-    }
-
-    const targetId = this.getReplyTarget(msg);
-    await this.sendFn(targetId, reply, msg.conversationType);
-  }
-
-  async handleClaw(msg) {
-    const targetId = this.getReplyTarget(msg);
-
-    // 发送已读回执（fire-and-forget，不阻塞）
-    if (this.sendReadReceiptFn) {
-      this.sendReadReceiptFn(msg).catch(() => {});
-    }
-
-    // 后台执行 openclaw，不阻塞消息队列
-    this.openclawClient.chat(msg.content, msg.senderUserId)
-      .then(reply => {
-        this.log?.info(`[MessageHandler] AI 回复: ${reply.substring(0, 50)}...`);
-        this.sendFn(targetId, reply, msg.conversationType).catch(() => {});
-      })
-      .catch(err => {
-        this.log?.error(`[MessageHandler] OpenClaw 调用失败: ${err.message}`);
-        this.sendFn(targetId, `❌ 处理失败: ${err.message}`, msg.conversationType).catch(() => {});
-      });
-  }
-
-  parseCommand(raw, senderId) {
-    const trimmed = raw.slice(1).trim();
-    const parts = trimmed.split(/\s+/);
-    return {
-      command: parts[0] || '',
-      args: parts.slice(1),
-      rawMessage: raw,
-      senderId
-    };
-  }
-}
-
-module.exports = { MessageHandler };
+const { MessageType } = require('./types');
+const { OpenClawClient } = require('./openclaw-client');
+const { handleNormalMessage } = require('../modules/normal-message-handler');
+const axios = require('axios');
+const MENTION_REGEX = /@(claw_[a-zA-Z0-9]+)/g;
+
+class MessageHandler {
+  constructor(config, sendFn, log, sendReadReceiptFn) {
+    this.config = config;
+    this.sendFn = sendFn;
+    this.log = log;
+    this.sendReadReceiptFn = sendReadReceiptFn;
+    this.openclawClient = new OpenClawClient(log);
+    this.nodeId = config.accountId || '';
+    this.handleNormalMessage = handleNormalMessage;
+  }
+
+  /**
+   * 判断是否支持流式处理
+   */
+  get isStreamingEnabled() {
+    return !!this.config.apiBaseUrl;
+  }
+
+  extractMentions(content) {
+    const mentions = [];
+    let match;
+    while ((match = MENTION_REGEX.exec(content)) !== null) {
+      mentions.push(match[1]);
+    }
+    MENTION_REGEX.lastIndex = 0;
+    return mentions;
+  }
+
+  shouldHandleMessage(msg) {
+    // 过滤离线消息：离线消息是历史记录，不需要重复处理
+    if (msg.isOffLineMessage) {
+      this.log?.info('[MessageHandler] 收到离线消息，忽略');
+      return false;
+    }
+
+    const allowedTypes = ['RC:TxtMsg', 'claw'];
+    if (!allowedTypes.includes(msg.messageType)) {
+      this.log?.info(`[MessageHandler] 忽略非文本消息: ${msg.messageType}`);
+      return false;
+    }
+
+    if (msg.senderUserId === this.config.accountId) {
+      this.log?.info('[MessageHandler] 忽略自己发送的消息');
+      return false;
+    }
+
+    // 优先从融云 mentionedInfo 提取被@用户列表（用户界面 @昵称，但融云底层存的是 userId）
+    let mentions = [];
+    if (msg.mentionedInfo && Array.isArray(msg.mentionedInfo.userIdList)) {
+      mentions = msg.mentionedInfo.userIdList;
+      if (mentions.length > 0) {
+        this.log?.info(`[MessageHandler] 融云 mentionedInfo: ${mentions.join(', ')}，本节点: ${this.nodeId}`);
+      }
+    }
+
+    // 兜底：从文本内容中正则匹配 @claw_xxx
+    if (mentions.length === 0) {
+      const textContent = typeof msg.content === 'string' ? msg.content : (msg.content?.content || '');
+      mentions = this.extractMentions(textContent);
+    }
+
+    if (mentions.length > 0) {
+      if (!mentions.includes(this.nodeId)) {
+        this.log?.info(`[MessageHandler] 消息 @${mentions.join(', ')}，非本节点(${this.nodeId})，忽略`);
+        return false;
+      }
+      this.log?.info(`[MessageHandler] 消息提及本节点(${this.nodeId})，处理`);
+    } else if (msg.conversationType === 3) {
+      // 群聊消息未 @ 任何人 → 视为所有人参与，正常处理
+      this.log?.info(`[MessageHandler] 群聊消息未 @ 任何人，本节点(${this.nodeId})参与处理`);
+    } else {
+      this.log?.info(`[MessageHandler] 单聊消息未指定节点，本节点(${this.nodeId})处理`);
+    }
+
+    return true;
+  }
+
+  async handleMessage(msg) {
+    if (!this.shouldHandleMessage(msg)) {
+      return;
+    }
+
+    try {
+      const type = this.getMessageType(msg);
+      const logContent = typeof msg.content === 'string' ? msg.content : (msg.content?.content || '');
+      this.log?.info(`[MessageHandler] 收到消息 from=${msg.senderUserId}, type=${type}, content=${logContent.substring(0, 50)}`);
+
+      if (msg.messageType === 'claw') {
+        this.log?.info(`收到龙虾消息，交由 OpenClawClient 处理`);
+        await this.handleClaw(msg);
+      } else {
+        // 如果配置了代理地址，使用流式处理
+        if (this.isStreamingEnabled) {
+          this.handleNormalMessageStream(msg).catch(err => {
+            this.log?.error(`[MessageHandler] 流式处理异常: ${err.message}`);
+          });
+        } else {
+          // 降级到非流式处理
+          const reply = await this.handleNormalMessage(msg);
+          if (reply) {
+            const targetId = this.getReplyTarget(msg);
+            await this.sendFn(targetId, reply, msg.conversationType);
+          }
+        }
+      }
+    } 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);
+    }
+  }
+
+  getMessageType(msg) {
+    if (msg.messageType === 'claw') {
+      return MessageType.CLAW;
+    }
+    const text = typeof msg.content === 'string' ? msg.content : (msg.content?.content || '');
+    if (text.startsWith('/')) {
+      return MessageType.COMMAND;
+    }
+    return MessageType.NORMAL;
+  }
+
+  getReplyTarget(msg) {
+    if (msg.conversationType === 3) {
+      return msg.targetId;
+    }
+    return msg.senderUserId;
+  }
+
+  async handleCommand(msg) {
+    const payload = this.parseCommand(msg.content, msg.senderUserId);
+    this.log?.info(`[MessageHandler] 指令消息: command=${payload.command}, args=${payload.args.join(', ')}`);
+
+    let reply;
+    if (this.config.onCommand) {
+      try {
+        reply = await this.config.onCommand(payload);
+      } catch (err) {
+        this.log?.error(`[MessageHandler] 指令处理回调异常: ${err.message}`);
+        reply = `指令执行异常: ${err.message}`;
+      }
+    } else {
+      reply = `指令 "${payload.command}" 暂未实现`;
+    }
+
+    const targetId = this.getReplyTarget(msg);
+    await this.sendFn(targetId, reply, msg.conversationType);
+  }
+
+  async handleClaw(msg) {
+    const targetId = this.getReplyTarget(msg);
+
+    // 发送已读回执（fire-and-forget，不阻塞）
+    if (this.sendReadReceiptFn) {
+      this.sendReadReceiptFn(msg).catch(() => {});
+    }
+
+    // 如果配置了代理地址，使用流式处理
+    if (this.isStreamingEnabled) {
+      this.handleNormalMessageStream(msg).catch(err => {
+        this.log?.error(`[MessageHandler] 流式处理异常: ${err.message}`);
+      });
+      return;
+    }
+
+    // 降级：后台执行 openclaw CLI，不阻塞消息队列
+    this.openclawClient.chat(msg.content, msg.senderUserId)
+      .then(reply => {
+        this.log?.info(`[MessageHandler] AI 回复: ${reply.substring(0, 50)}...`);
+        this.sendFn(targetId, reply, msg.conversationType).catch(() => {});
+      })
+      .catch(err => {
+        this.log?.error(`[MessageHandler] OpenClaw 调用失败: ${err.message}`);
+        this.sendFn(targetId, `❌ 处理失败: ${err.message}`, msg.conversationType).catch(() => {});
+      });
+  }
+
+  /**
+   * 流式处理普通消息
+   */
+  async handleNormalMessageStream(msg) {
+    const targetId = this.getReplyTarget(msg);
+    const streamId = `${Date.now()}-${Math.random().toString(36).substring(2, 10)}`;
+    let isFirstChunk = true;
+    let buffer = '';
+    const fromUserId = this.config.accountId;
+    const conversationType = msg.conversationType;
+
+    // 1. 发送 typing 状态
+    await this._sendTypingStatus(fromUserId, targetId, conversationType);
+
+    this.log?.info(`[MessageHandler] 开始流式处理，streamId=${streamId}`);
+
+    // 2. 调用 OpenClaw SSE
+    return this.openclawClient.chatStream(
+      msg.content,
+      msg.senderUserId,
+      async (delta) => {
+        buffer += delta;
+        // 策略：每 30 个字符或遇到句末标点发送一次片段
+        if (buffer.length >= 30 || /[。！？.!?\n]$/.test(delta)) {
+          await this._sendStreamChunk(fromUserId, targetId, conversationType, buffer, streamId, isFirstChunk, false);
+          isFirstChunk = false;
+          buffer = '';
+        }
+      },
+      async (fullText) => {
+        // 发送剩余缓冲区和结束标记
+        if (buffer.trim()) {
+          await this._sendStreamChunk(fromUserId, targetId, conversationType, buffer, streamId, isFirstChunk, true);
+        } else if (!isFirstChunk) {
+          // 已经发送过内容，单独发送结束标记
+          await this._sendStreamChunk(fromUserId, targetId, conversationType, '', streamId, false, true);
+        } else {
+          // 完全没有收到内容，发送错误提示
+          await this._sendStreamChunk(fromUserId, targetId, conversationType, '抱歉，AI 暂时没有回复内容。', streamId, true, true);
+        }
+        this.log?.info(`[MessageHandler] 流式消息完成，streamId=${streamId}, 总长度: ${fullText.length}`);
+      },
+      async (err) => {
+        this.log?.error(`[MessageHandler] 流式处理错误: ${err.message}`);
+        await this._sendStreamChunk(fromUserId, targetId, conversationType, '抱歉，AI 响应出现错误，请稍后重试。', streamId, isFirstChunk, true);
+      }
+    );
+  }
+
+  /**
+   * 发送 typing 状态（通过 Python 后端代理）
+   */
+  async _sendTypingStatus(fromUserId, targetId, conversationType) {
+    if (!this.isStreamingEnabled) return;
+    try {
+      await axios.post(
+        `${this.config.apiBaseUrl}/im/api/proxy/stream/typing`,
+        {
+          fromUserId,
+          targetId,
+          conversationType
+        },
+        { timeout: 5000 }
+      );
+      this.log?.info(`[MessageHandler] typing 状态已发送: ${fromUserId} -> ${targetId}`);
+    } catch (err) {
+      this.log?.warn(`[MessageHandler] 发送 typing 状态失败: ${err.message}`);
+    }
+  }
+
+  /**
+   * 发送流式消息片段（通过 Python 后端代理）
+   */
+  async _sendStreamChunk(fromUserId, targetId, conversationType, content, streamId, isFirstChunk, isLastChunk) {
+    if (!this.isStreamingEnabled) return;
+    try {
+      await axios.post(
+        `${this.config.apiBaseUrl}/im/api/proxy/stream/publish`,
+        {
+          fromUserId,
+          targetId,
+          content,
+          streamId,
+          isFirstChunk,
+          isLastChunk,
+          conversationType
+        },
+        { timeout: 10000 }
+      );
+    } catch (err) {
+      this.log?.warn(`[MessageHandler] 发送流式消息失败: ${err.message}`);
+    }
+  }
+
+  parseCommand(raw, senderId) {
+    const trimmed = raw.slice(1).trim();
+    const parts = trimmed.split(/\s+/);
+    return {
+      command: parts[0] || '',
+      args: parts.slice(1),
+      rawMessage: raw,
+      senderId
+    };
+  }
+}
+
+module.exports = { MessageHandler };

package/service/rongcloud/openclaw-client.js

@@ -282,6 +282,108 @@ class OpenClawClient {
     return this.chatViaCLI(message, fromUser);
   }
 
+  /**
+   * 流式调用 OpenClaw（SSE）
+   * 调用 OpenClaw Gateway 的 /v1/chat/completions SSE 端点
+   *
+   * @param {string} message - 用户消息
+   * @param {string} fromUser - 用户ID（用于session隔离）
+   * @param {Function} onDelta - 每次收到内容块时的回调 (chunk: string) => void
+   * @param {Function} onDone - 流结束时的回调 (fullText: string) => void
+   * @param {Function} onError - 出错时的回调 (error: Error) => void
+   * @returns {Promise<void>}
+   */
+  async chatStream(message, fromUser, onDelta, onDone, onError) {
+    if (!message || !message.trim()) {
+      onError?.(new Error('消息内容为空'));
+      return;
+    }
+
+    const gatewayReady = await this.ensureGatewayRunning();
+    if (!gatewayReady) {
+      const err = new Error('OpenClaw gateway 启动失败');
+      this.log?.error('[OpenClawClient] ' + err.message);
+      onError?.(err);
+      return;
+    }
+
+    this.log?.info(`[OpenClawClient] 准备 SSE 流式调用 OpenClaw，from=${fromUser}`);
+
+    const gatewayToken = getGatewayToken();
+    const sessionId = `clawmessenger-${fromUser}`;
+    const apiUrl = 'http://127.0.0.1:18789/v1/chat/completions';
+
+    const headers = {
+      'Content-Type': 'application/json',
+      'Accept': 'text/event-stream'
+    };
+    if (gatewayToken) {
+      headers['Authorization'] = `Bearer ${gatewayToken}`;
+    }
+
+    const payload = {
+      model: 'openclaw',
+      messages: [
+        { role: 'user', content: message }
+      ],
+      stream: true,
+      session_id: sessionId
+    };
+
+    let fullText = '';
+    let buffer = '';
+
+    try {
+      const response = await axios.post(apiUrl, payload, {
+        headers,
+        responseType: 'stream',
+        timeout: 600000 // 10 分钟
+      });
+
+      response.data.on('data', (chunk) => {
+        buffer += chunk.toString();
+        const lines = buffer.split('\n');
+        buffer = lines.pop(); // 保留未完整的最后一行
+
+        for (const line of lines) {
+          const trimmed = line.trim();
+          if (!trimmed || !trimmed.startsWith('data: ')) continue;
+
+          const dataStr = trimmed.slice(6).trim();
+          if (dataStr === '[DONE]') continue;
+
+          try {
+            const data = JSON.parse(dataStr);
+            const delta = data.choices?.[0]?.delta?.content;
+            if (delta) {
+              fullText += delta;
+              onDelta?.(delta);
+            }
+          } catch {
+            // 忽略无法解析的 JSON 行
+          }
+        }
+      });
+
+      return new Promise((resolve, reject) => {
+        response.data.on('end', () => {
+          this.log?.info(`[OpenClawClient] SSE 流结束，总长度: ${fullText.length}`);
+          onDone?.(fullText);
+          resolve();
+        });
+
+        response.data.on('error', (err) => {
+          this.log?.error(`[OpenClawClient] SSE 流错误: ${err.message}`);
+          onError?.(err);
+          reject(err);
+        });
+      });
+    } catch (err) {
+      this.log?.error(`[OpenClawClient] SSE 请求失败: ${err.message}`);
+      onError?.(err);
+    }
+  }
+
   async chatViaCLI(message, fromUser) {
     const sessionId = `clawmessenger-${fromUser}`;
 

package/service/worker.js

@@ -198,12 +198,16 @@ function loadRongCloudConfig() {
       config.appKey = localConfig.appKey || config.appKey;
       if (localConfig.token) config.token = localConfig.token;
       if (localConfig.accountId) config.accountId = localConfig.accountId;
+      if (localConfig.appSecret) config.appSecret = localConfig.appSecret;
       log.info(`[WORKER] 从本地配置加载: appKey=${config.appKey?.substring(0, 8)}...`);
     }
   } catch (err) {
     log.error(`[WORKER] 加载本地配置失败: ${err.message}`);
   }
 
+  // 加载 apiBaseUrl（Python 后端地址，用于代理发送流式消息）
+  config.apiBaseUrl = process.env.API_BASE_URL || config.apiBaseUrl || 'http://127.0.0.1:5000';
+
   if (!config.appKey) {
     config.appKey = process.env.DM_APP_KEY || 'bmdehs6pbyyks';
     log.info(`[WORKER] 使用默认 appKey: ${config.appKey}`);