claw-subagent-service 0.0.72 → 0.0.74

package/package.json

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

package/service/modules/system-config.js

@@ -0,0 +1,78 @@
+/**
+ * 系统配置获取模块
+ * 从 Python 服务端动态获取融云配置（appKey, appSecret 等）
+ */
+
+const axios = require('axios');
+
+class SystemConfigManager {
+  constructor(config, log) {
+    this.config = config;
+    this.log = log;
+    this.serverUrl = config.apiBaseUrl || process.env.DM_SERVER_URL || 'https://newsradar.dreamdt.cn/im';
+    this.configs = new Map();
+    this.lastFetchTime = 0;
+    this.fetchInterval = 5 * 60 * 1000; // 5分钟刷新一次
+  }
+
+  /**
+   * 从服务端获取配置
+   */
+  async fetchConfig(configKey) {
+    try {
+      const url = `${this.serverUrl}/api/system/config/${configKey}`;
+      const response = await axios.get(url, { timeout: 10000 });
+      
+      if (response.data?.code === 200 && response.data?.data?.value) {
+        this.configs.set(configKey, response.data.data.value);
+        this.lastFetchTime = Date.now();
+        this.log?.info(`[SystemConfig] 获取配置成功: ${configKey}`);
+        return response.data.data.value;
+      }
+      
+      this.log?.warn(`[SystemConfig] 获取配置失败: ${configKey}, code=${response.data?.code}`);
+      return null;
+    } catch (err) {
+      this.log?.error(`[SystemConfig] 获取配置异常: ${configKey}, ${err.message}`);
+      return null;
+    }
+  }
+
+  /**
+   * 获取配置值（带缓存）
+   */
+  async getConfig(configKey) {
+    // 检查缓存是否过期
+    const now = Date.now();
+    if (this.configs.has(configKey) && (now - this.lastFetchTime) < this.fetchInterval) {
+      return this.configs.get(configKey);
+    }
+    
+    // 重新获取
+    return this.fetchConfig(configKey);
+  }
+
+  /**
+   * 批量获取配置
+   */
+  async getConfigs(keys) {
+    const results = {};
+    for (const key of keys) {
+      results[key] = await this.getConfig(key);
+    }
+    return results;
+  }
+
+  /**
+   * 强制刷新配置
+   */
+  async refresh() {
+    this.lastFetchTime = 0;
+    const keys = Array.from(this.configs.keys());
+    for (const key of keys) {
+      await this.fetchConfig(key);
+    }
+  }
+}
+
+module.exports = { SystemConfigManager };

package/service/rongcloud/message-handler.js

@@ -1,6 +1,8 @@
 const { MessageType } = require('./types');
 const { OpenClawClient } = require('./openclaw-client');
 const { handleNormalMessage } = require('../modules/normal-message-handler');
+const { RongCloudServerAPI } = require('./rongcloud-server-api');
+const { SystemConfigManager } = require('../modules/system-config');
 const axios = require('axios');
 const MENTION_REGEX = /@(claw_[a-zA-Z0-9]+)/g;
 
@@ -11,18 +13,30 @@ class MessageHandler {
     this.log = log;
     this.sendReadReceiptFn = sendReadReceiptFn;
     this.openclawClient = new OpenClawClient(log);
+    // 初始化系统配置管理器（从 Python 服务端动态获取配置）
+    this.configManager = new SystemConfigManager(config, log);
+    // 初始化融云服务端 API 客户端（直接调用融云 API，无需通过服务端代理）
+    this.serverAPI = new RongCloudServerAPI(this.configManager, log);
+    this.log?.info('[MessageHandler] 融云服务端 API 客户端已初始化（配置从服务端动态获取）');
     this.nodeId = config.accountId || '';
     this.handleNormalMessage = handleNormalMessage;
     this._streamQueue = Promise.resolve();
     // 存储流式消息的 RongCloud messageUID：streamId -> messageUID
     this._streamMessageUIDs = new Map();
+    // 群聊对话轮数统计：groupId -> currentRound
+    this._groupRoundCounts = new Map();
+    // 群组配置缓存：groupId -> { maxRounds, expiresAt }
+    this._groupConfigCache = new Map();
+    this._defaultMaxRounds = 10;
+    this._groupConfigCacheTTL = config.groupConfigCacheTTL || 60000; // 默认缓存 60 秒
   }
 
   /**
    * 判断是否支持流式处理
+   * 现在配置从服务端动态获取，总是启用
    */
   get isStreamingEnabled() {
-    return !!this.config.apiBaseUrl;
+    return !!this.serverAPI;
   }
 
   extractMentions(content) {
@@ -84,6 +98,71 @@ class MessageHandler {
     return true;
   }
 
+  /**
+   * 获取群聊当前轮数
+   */
+  _getGroupRoundCount(groupId) {
+    return this._groupRoundCounts.get(groupId) || 0;
+  }
+
+  /**
+   * 增加群聊轮数
+   */
+  _incrementGroupRoundCount(groupId, maxRounds) {
+    const current = this._getGroupRoundCount(groupId);
+    this._groupRoundCounts.set(groupId, current + 1);
+    this.log?.info(`[MessageHandler] 群聊 ${groupId} 轮数 +1，当前: ${current + 1}/${maxRounds}`);
+  }
+
+  /**
+   * 重置群聊轮数
+   */
+  _resetGroupRoundCount(groupId) {
+    this._groupRoundCounts.set(groupId, 0);
+    this.log?.info(`[MessageHandler] 群聊 ${groupId} 轮数已重置`);
+  }
+
+  /**
+   * 从后端 API 获取群组配置
+   */
+  async _fetchGroupConfig(groupId) {
+    try {
+      const apiUrl = `${this.config.apiBaseUrl}/im/api/group/info`;
+      this.log?.info(`[MessageHandler] 查询群组配置: groupId=${groupId}, url=${apiUrl}`);
+      const resp = await axios.get(apiUrl, {
+        params: { groupId: groupId },
+        timeout: 5000
+      });
+      if (resp.data?.code === 200 && resp.data.data) {
+        const maxRounds = resp.data.data.maxRounds;
+        if (typeof maxRounds === 'number') {
+          this.log?.info(`[MessageHandler] 群组 ${groupId} 配置: maxRounds=${maxRounds}`);
+          return maxRounds;
+        }
+      }
+    } catch (err) {
+      this.log?.warn(`[MessageHandler] 获取群组配置失败: ${err.message}`);
+    }
+    return this._defaultMaxRounds;
+  }
+
+  /**
+   * 获取群组最大轮数（带缓存）
+   */
+  async _getGroupMaxRounds(groupId) {
+    const cached = this._groupConfigCache.get(groupId);
+    const now = Date.now();
+    if (cached && cached.expiresAt > now) {
+      return cached.maxRounds;
+    }
+    const maxRounds = await this._fetchGroupConfig(groupId);
+    this._groupConfigCache.set(groupId, {
+      maxRounds,
+      expiresAt: now + this._groupConfigCacheTTL
+    });
+    return maxRounds;
+  }
+
   async handleMessage(msg) {
     if (!this.shouldHandleMessage(msg)) {
       return;
@@ -94,16 +173,64 @@ class MessageHandler {
       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)}`);
 
+      // 群聊轮数控制（仅对群聊生效）
+      let maxRounds = this._defaultMaxRounds;
+      if (msg.conversationType === 3) {
+        const groupId = msg.targetId;
+        maxRounds = await this._getGroupMaxRounds(groupId);
+        const currentRounds = this._getGroupRoundCount(groupId);
+
+        // 处理内置轮数相关命令
+        if (type === MessageType.COMMAND) {
+          const payload = this.parseCommand(msg.content, msg.senderUserId);
+          if (payload.command === 'newround') {
+            this._resetGroupRoundCount(groupId);
+            await this.sendFn(groupId, `✅ 新一轮对话已开始，最大对话轮数为 ${maxRounds} 轮。`, msg.conversationType);
+            return;
+          }
+          if (payload.command === 'roundstatus') {
+            const remaining = Math.max(0, maxRounds - currentRounds);
+            const statusMsg = currentRounds >= maxRounds
+              ? `⛔ 本轮对话已结束（已达 ${maxRounds} 轮）。发送 /newround 开启新一轮。`
+              : `📊 当前对话进度：第 ${currentRounds + 1}/${maxRounds} 轮，剩余 ${remaining} 轮。`;
+            await this.sendFn(groupId, statusMsg, msg.conversationType);
+            return;
+          }
+        }
+
+        // 检查是否已达最大轮数
+        if (currentRounds >= maxRounds) {
+          this.log?.info(`[MessageHandler] 群聊 ${groupId} 已达到最大轮数 ${maxRounds}，拒绝处理`);
+          await this.sendFn(groupId, `⛔ 本轮对话已达到最大轮数（${maxRounds} 轮），对话已结束。\n\n发送 /newround 可开启新一轮对话。`, msg.conversationType);
+          return;
+        }
+      }
+
+      // 发送已读回执（fire-and-forget，不阻塞消息处理）
+      if (this.sendReadReceiptFn && msg.messageUId) {
+        this.sendReadReceiptFn(msg).catch((err) => {
+          this.log?.warn(`[MessageHandler] 发送已读回执失败: ${err.message}`);
+        });
+      }
+
       // 如果配置了代理地址，使用流式处理
       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);
+            }
           }
         }
       } else {
@@ -112,6 +239,10 @@ class MessageHandler {
         if (reply) {
           const targetId = this.getReplyTarget(msg);
           await this.sendFn(targetId, reply, msg.conversationType);
+          // 非流式处理成功，群聊轮数 +1
+          if (msg.conversationType === 3) {
+            this._incrementGroupRoundCount(msg.targetId, maxRounds);
+          }
         }
       }
     } catch (err) {
@@ -174,6 +305,23 @@ class MessageHandler {
 
     // 2. 调用 OpenClaw SSE
     let hasSentChunk = false;
+    // typing 刷新定时器：每次 delta 时刷新 typing，超时后自动停止
+    let typingTimer = null;
+    const refreshTyping = async () => {
+      // 清除旧的超时
+      if (typingTimer) {
+        clearTimeout(typingTimer);
+        typingTimer = null;
+      }
+      // 发送 typing
+      await this._sendTypingStatus(fromUserId, targetId, conversationType);
+      // 设置 3 秒超时，如果 3 秒内没有新的 delta，typing 自动消失
+      typingTimer = setTimeout(() => {
+        this.log?.info(`[MessageHandler] typing 超时自动清除: streamId=${streamId}`);
+        typingTimer = null;
+      }, 3000);
+    };
+
     try {
       // 确保传入的内容是字符串（claw 类型消息 content 可能是对象）
       const chatContent = typeof msg.content === 'string' ? msg.content : (msg.content?.content || JSON.stringify(msg.content));
@@ -188,9 +336,18 @@ class MessageHandler {
           // 发送增量（delta），让前端做增量拼接，避免内容重复
           await this._sendStreamChunk(fromUserId, targetId, conversationType, delta, streamId, seq === 1, false, seq);
           hasSentChunk = true;
+          // 每次有输出时刷新 typing 状态
+          await refreshTyping();
         },
         async (fullText) => {
           this.log?.info(`[MessageHandler] onDone 触发, fullText.length=${fullText.length}, buffer.length=${buffer.length}, hasSentChunk=${hasSentChunk}`);
+          
+          // 清除 typing 定时器
+          if (typingTimer) {
+            clearTimeout(typingTimer);
+            typingTimer = null;
+          }
+          
           if (buffer.trim()) {
             // 发送尾流：空字符串表示流结束，前端保留已拼接的完整内容
             seq += 1;
@@ -214,10 +371,34 @@ class MessageHandler {
           
           // 清理已存储的 messageUID，防止内存泄漏
           this._streamMessageUIDs.delete(streamId);
+          
+          // 发送持久化的普通文本消息作为历史记录（融云会保存 RC:TxtMsg）
+          if (buffer.trim()) {
+            try {
+              this.log?.info(`[MessageHandler] 发送历史记录文本消息: length=${buffer.length}`);
+              // 使用 JSON 格式包含 streamId，前端可据此关联并更新流式消息内容
+              const historyContent = JSON.stringify({
+                __stream_history__: true,
+                streamId: streamId,
+                text: buffer,
+                sentTime: Date.now()
+              });
+              await this.sendFn(targetId, historyContent, conversationType);
+            } catch (err) {
+              this.log?.error(`[MessageHandler] 发送历史记录失败: ${err.message}`);
+            }
+          }
         }
       );
     } catch (err) {
       this.log?.error(`[MessageHandler] 流式处理错误: ${err.message}`);
+      
+      // 清除 typing 定时器
+      if (typingTimer) {
+        clearTimeout(typingTimer);
+        typingTimer = null;
+      }
+      
       await this._sendStreamChunk(fromUserId, targetId, conversationType, '抱歉，AI 响应出现错误，请稍后重试。', streamId, true, true, 1);
       
       // 错误时也要清理
@@ -227,36 +408,30 @@ class MessageHandler {
   }
 
   /**
-   * 发送 typing 状态（通过 Python 后端代理）
+   * 发送 typing 状态（直接调用融云 API）
    */
   async _sendTypingStatus(fromUserId, targetId, conversationType) {
-    if (!this.isStreamingEnabled) return;
+    if (!this.isStreamingEnabled || !this.serverAPI) return;
     try {
-      await axios.post(
-        `${this.config.apiBaseUrl}/im/api/proxy/stream/typing`,
-        {
-          fromUserId,
-          targetId,
-          conversationType
-        },
-        { timeout: 5000 }
-      );
+      await this.serverAPI.sendTypingStatus({
+        fromUserId,
+        toUserId: targetId,
+        conversationType
+      });
       this.log?.info(`[MessageHandler] typing 状态已发送: ${fromUserId} -> ${targetId}`);
     } catch (err) {
-      const url = `${this.config.apiBaseUrl}/im/api/proxy/stream/typing`;
-      const status = err.response?.status;
-      this.log?.warn(`[MessageHandler] 发送 typing 状态失败: ${err.message}, url=${url}, status=${status || 'N/A'}`);
+      this.log?.warn(`[MessageHandler] 发送 typing 状态失败: ${err.message}`);
     }
   }
 
   /**
-   * 发送流式消息片段（通过 Python 后端代理）
+   * 发送流式消息片段（直接调用融云 API）
    */
   async _sendStreamChunk(fromUserId, targetId, conversationType, content, streamId, isFirstChunk, isLastChunk, seq = 1) {
     const contentPreview = typeof content === 'string' ? content.substring(0, 100) : JSON.stringify(content).substring(0, 100);
     this.log?.info(`[MessageHandler] _sendStreamChunk ENTRY: target=${targetId}, streamId=${streamId}, seq=${seq}, first=${isFirstChunk}, last=${isLastChunk}, content_len=${content?.length || 0}, content_preview=${contentPreview}`);
-    if (!this.isStreamingEnabled) {
-      this.log?.warn('[MessageHandler] _sendStreamChunk  skipped: isStreamingEnabled=false');
+    if (!this.isStreamingEnabled || !this.serverAPI) {
+      this.log?.warn('[MessageHandler] _sendStreamChunk  skipped: 未配置 appKey/appSecret');
       return;
     }
     
@@ -266,36 +441,42 @@ class MessageHandler {
         // 获取已存储的 RongCloud messageUID（首流响应返回的）
         const messageUID = this._streamMessageUIDs.get(streamId);
         
-        const payload = {
-          fromUserId,
-          targetId,
-          content,
-          streamId,
-          isFirstChunk,
-          isLastChunk,
-          conversationType,
-          seq,
-          messageUID
-        };
-        this.log?.info(`[MessageHandler] _sendStreamChunk 请求体: ${JSON.stringify(payload).substring(0, 300)}`);
-        const resp = await axios.post(
-          `${this.config.apiBaseUrl}/im/api/proxy/stream/publish`,
-          payload,
-          { timeout: 10000 }
-        );
+        let result;
+        if (conversationType === 3) {
+          // 群聊流式消息
+          result = await this.serverAPI.sendStreamGroup({
+            fromUserId,
+            toGroupId: targetId,
+            content,
+            streamId,
+            isFirstChunk,
+            isLastChunk,
+            seq,
+            messageUID
+          });
+        } else {
+          // 单聊流式消息
+          result = await this.serverAPI.sendStreamPrivate({
+            fromUserId,
+            toUserId: targetId,
+            content,
+            streamId,
+            isFirstChunk,
+            isLastChunk,
+            seq,
+            messageUID
+          });
+        }
         
         // 首流时存储 RongCloud 返回的 messageUID
-        if (isFirstChunk && resp.data?.messageUID) {
-          this._streamMessageUIDs.set(streamId, resp.data.messageUID);
-          this.log?.info(`[MessageHandler] 首流 messageUID 已存储: ${resp.data.messageUID}, streamId=${streamId}`);
+        if (isFirstChunk && result?.messageUID) {
+          this._streamMessageUIDs.set(streamId, result.messageUID);
+          this.log?.info(`[MessageHandler] 首流 messageUID 已存储: ${result.messageUID}, streamId=${streamId}`);
         }
         
-        this.log?.info(`[MessageHandler] _sendStreamChunk 成功: status=${resp.status}, seq=${seq}, response=${JSON.stringify(resp.data).substring(0, 200)}`);
+        this.log?.info(`[MessageHandler] _sendStreamChunk 成功: seq=${seq}`);
       } catch (err) {
-        const url = `${this.config.apiBaseUrl}/im/api/proxy/stream/publish`;
-        const status = err.response?.status;
-        const responseData = err.response?.data ? JSON.stringify(err.response.data).substring(0, 200) : 'N/A';
-        this.log?.warn(`[MessageHandler] 发送流式消息失败: ${err.message}, url=${url}, status=${status || 'N/A'}, response=${responseData}, seq=${seq}`);
+        this.log?.warn(`[MessageHandler] 发送流式消息失败: ${err.message}, seq=${seq}`);
       }
     });
     

package/service/rongcloud/rongcloud-server-api.js

@@ -0,0 +1,236 @@
+/**
+ * 融云服务端 API 客户端
+ * 直接从 silent-service 调用融云 REST API，无需通过服务端代理
+ * 文档: https://docs.rongcloud.cn/platform-chat-api/message/send-private-stream
+ */
+
+const axios = require('axios');
+const crypto = require('crypto');
+
+// 国内数据中心 API 地址
+const API_HOSTS_CN = [
+  'api.rong-api.com',
+  'api-b.rong-api.com'
+];
+
+class RongCloudServerAPI {
+  constructor(configManager, log) {
+    this.configManager = configManager;
+    this.log = log;
+    this.hosts = API_HOSTS_CN;
+    this.currentHostIndex = 0;
+    this.timeout = 10000;
+  }
+
+  get currentHost() {
+    return this.hosts[this.currentHostIndex];
+  }
+
+  _switchHost() {
+    if (this.currentHostIndex < this.hosts.length - 1) {
+      this.currentHostIndex++;
+      this.log?.info(`[RongCloudServerAPI] 切换到备用域名: ${this.currentHost}`);
+      return true;
+    }
+    return false;
+  }
+
+  _generateNonce(length = 18) {
+    const chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789';
+    let result = '';
+    for (let i = 0; i < length; i++) {
+      result += chars.charAt(Math.floor(Math.random() * chars.length));
+    }
+    return result;
+  }
+
+  _generateSignature(appSecret) {
+    const nonce = this._generateNonce();
+    const timestamp = Date.now();
+    const source = appSecret + nonce + timestamp;
+    const signature = crypto.createHash('sha1').update(source).digest('hex');
+    return { nonce, timestamp, signature };
+  }
+
+  _getHeaders(appKey, appSecret) {
+    const sign = this._generateSignature(appSecret);
+    return {
+      'App-Key': appKey,
+      'Nonce': sign.nonce,
+      'Timestamp': String(sign.timestamp),
+      'Signature': sign.signature,
+      'Content-Type': 'application/json; charset=UTF-8'
+    };
+  }
+
+  async request(path, data, appKey, appSecret, retry = true) {
+    const url = `https://${this.currentHost}${path}`;
+    const headers = this._getHeaders(appKey, appSecret);
+
+    this.log?.info(`[RongCloudServerAPI] 请求: POST ${url}`);
+
+    try {
+      const response = await axios.post(url, data, {
+        headers,
+        timeout: this.timeout,
+        responseType: 'json'
+      });
+
+      const result = response.data;
+
+      if (result.code && result.code !== 200) {
+        throw new Error(`[${result.code}] ${result.errorMessage || 'Unknown error'}`);
+      }
+
+      return result;
+    } catch (err) {
+      if (err.response?.status === 401) {
+        this.log?.error('[RongCloudServerAPI] 签名验证失败，请检查 App Key 和 App Secret');
+        throw err;
+      }
+
+      if (retry && this._switchHost()) {
+        this.log?.warn(`[RongCloudServerAPI] 请求失败，使用备用域名重试: ${err.message}`);
+        return this.request(path, data, appKey, appSecret, false);
+      }
+
+      this.log?.error(`[RongCloudServerAPI] 请求失败: ${err.message}`);
+      throw err;
+    }
+  }
+
+  /**
+   * 获取融云配置
+   */
+  async _getRongCloudConfig() {
+    const configs = await this.configManager.getConfigs([
+      'rongcloud_app_key',
+      'rongcloud_app_secret'
+    ]);
+    
+    if (!configs.rongcloud_app_key || !configs.rongcloud_app_secret) {
+      throw new Error('融云配置未找到，请先配置 rongcloud_app_key 和 rongcloud_app_secret');
+    }
+    
+    return {
+      appKey: configs.rongcloud_app_key,
+      appSecret: configs.rongcloud_app_secret
+    };
+  }
+
+  /**
+   * 发送单聊流式消息
+   */
+  async sendStreamPrivate({
+    fromUserId,
+    toUserId,
+    content,
+    streamId,
+    isFirstChunk = false,
+    isLastChunk = false,
+    seq = 1,
+    streamType = 'markdown',
+    messageUID = null
+  }) {
+    const { appKey, appSecret } = await this._getRongCloudConfig();
+    
+    const contentBody = {
+      content,
+      complete: isLastChunk,
+      seq
+    };
+
+    if (isFirstChunk) {
+      contentBody.type = streamType;
+    }
+
+    if (!isFirstChunk && messageUID) {
+      contentBody.messageUID = messageUID;
+    }
+
+    const data = {
+      fromUserId,
+      toUserId,
+      objectName: 'RC:StreamMsg',
+      content: contentBody,
+      isPersisted: 1,
+      isCounted: isFirstChunk ? 1 : 0,
+      disableUpdateLastMsg: !isLastChunk
+    };
+
+    this.log?.info(`[RongCloudServerAPI] 发送单聊流式消息: to=${toUserId}, streamId=${streamId}, first=${isFirstChunk}, last=${isLastChunk}, seq=${seq}`);
+    return this.request('/v3/message/private/publish_stream.json', data, appKey, appSecret);
+  }
+
+  /**
+   * 发送群聊流式消息
+   */
+  async sendStreamGroup({
+    fromUserId,
+    toGroupId,
+    content,
+    streamId,
+    isFirstChunk = false,
+    isLastChunk = false,
+    seq = 1,
+    streamType = 'markdown',
+    messageUID = null
+  }) {
+    const { appKey, appSecret } = await this._getRongCloudConfig();
+    
+    const contentBody = {
+      content,
+      complete: isLastChunk,
+      seq
+    };
+
+    if (isFirstChunk) {
+      contentBody.type = streamType;
+    }
+
+    if (!isFirstChunk && messageUID) {
+      contentBody.messageUID = messageUID;
+    }
+
+    const data = {
+      fromUserId,
+      toGroupId,
+      objectName: 'RC:StreamMsg',
+      content: contentBody,
+      isPersisted: 1,
+      isCounted: isFirstChunk ? 1 : 0,
+      isIncludeSender: 1,
+      disableUpdateLastMsg: !isLastChunk
+    };
+
+    this.log?.info(`[RongCloudServerAPI] 发送群聊流式消息: to=${toGroupId}, streamId=${streamId}, first=${isFirstChunk}, last=${isLastChunk}, seq=${seq}`);
+    return this.request('/v3/message/group/publish_stream.json', data, appKey, appSecret);
+  }
+
+  /**
+   * 发送 typing 状态
+   */
+  async sendTypingStatus({ fromUserId, toUserId, conversationType = 1 }) {
+    const { appKey, appSecret } = await this._getRongCloudConfig();
+    
+    const content = JSON.stringify({ typingContentType: 'RC:TxtMsg' }, { ensureAscii: false });
+    
+    const data = {
+      fromUserId,
+      toUserId,
+      objectName: 'RC:TypSts',
+      content,
+      isPersisted: 0,
+      isCounted: 0
+    };
+
+    this.log?.info(`[RongCloudServerAPI] 发送 typing 状态: ${fromUserId} -> ${toUserId}`);
+    
+    if (conversationType === 3) {
+      return this.request('/message/group/publish.json', data, appKey, appSecret);
+    }
+    return this.request('/message/private/publish.json', data, appKey, appSecret);
+  }
+}
+
+module.exports = { RongCloudServerAPI };

package/service/worker.js

@@ -199,7 +199,7 @@ 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;
+      // appSecret 不再从本地配置加载，统一从服务端获取
       if (localConfig.apiBaseUrl) config.apiBaseUrl = localConfig.apiBaseUrl;
       log.info(`[WORKER] 从本地配置加载: appKey=${config.appKey?.substring(0, 8)}...`);
     }