@xgjktech/xg_cwork_im 1.0.2 → 1.0.4

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@xgjktech/xg_cwork_im",
-  "version": "1.0.2",
+  "version": "1.0.4",
   "description": "XG CWork IM channel plugin for OpenClaw",
   "keywords": [
     "bot",
@@ -24,6 +24,7 @@
     "install:prod": "npm install --omit=dev"
   },
   "dependencies": {
+    "@sinclair/typebox": "^0.32.0",
     "axios": "^1.6.0",
     "ws": "^8.17.0",
     "zod": "^3.22.0"

package/src/channel.ts

@@ -392,6 +392,17 @@ export const xgCworkImChannelPlugin: XgImChannelPlugin = {
                         XgImExt: msgExt,
                     });
 
+                    // 若消息内容为 /reset，则在将其转交给 OpenClaw 之前完整打印一次入站上下文，便于排查 reset 行为
+                    if (text.trim() === "/reset") {
+                        try {
+                            log.info?.(
+                                `${logPrefix} [reset] inboundCtx payload before dispatch: ${JSON.stringify(inboundCtx)}`,
+                            );
+                        } catch {
+                            // 忽略 JSON 序列化异常，避免影响正常流程
+                        }
+                    }
+
                     // 【所有消息都必须做】记录到数据库！让 AI 产生“记忆”
                     log.info(`${logPrefix} [session] Recording inbound session sessionKey=${inboundCtx.SessionKey || route.sessionKey}`);
                     await rt.channel.session.recordInboundSession({
@@ -423,17 +434,23 @@ export const xgCworkImChannelPlugin: XgImChannelPlugin = {
 
                         // 2. 分发消息给 AI，deliver 回调负责把增量文本通过 CHUNK 推给 IM
                         let fullText = "";
+                        // think 与 answer 阶段各自维护 seq，便于集群/跨服务按序重排
+                        let thinkSeq = 0;
+                        let answerSeq = 0;
 
                         await rt.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
                             ctx: inboundCtx,
                             cfg: ctx.cfg,
                             dispatcherOptions: {
                                 responsePrefix: "",
-                                deliver: async (payload: { markdown?: string; text?: string }) => {
+                                deliver: async (payload: { markdown?: string; text?: string; isThinking?: boolean }) => {
                                     try {
                                         const textToSend = payload.markdown || payload.text;
                                         if (!textToSend) return;
 
+                                        const isThinking = payload.isThinking === true;
+                                        const seq = isThinking ? thinkSeq++ : answerSeq++;
+
                                         if (isFirstReply) {
                                             const ttfr = Date.now() - dispatchStart;
                                             log.info(`${logPrefix} [deliver] First response block received from AI (TTFB: ${ttfr}ms)`);
@@ -442,14 +459,14 @@ export const xgCworkImChannelPlugin: XgImChannelPlugin = {
 
                                         fullText += textToSend;
 
-                                        // 将增量 block 以 CHUNK 形式推给 IM
+                                        // 将增量 block 以 CHUNK 形式推给 IM，带 seq 便于服务端按序
                                         await wsHandle.streamClient.chunk(msgId, {
-                                            // 目前没有单独的“思考流”标记，全部作为正式回答输出
-                                            isThinking: false,
+                                            isThinking,
                                             content: textToSend,
+                                            seq,
                                         });
                                         log.info(
-                                            `${logPrefix} [stream] CHUNK sent: msgId=${msgId} length=${textToSend.length}`,
+                                            `${logPrefix} [stream] CHUNK sent: msgId=${msgId} isThinking=${isThinking} seq=${seq} length=${textToSend.length}`,
                                         );
                                     } catch (err: unknown) {
                                         log.error(`${logPrefix} Reply deliver failed: ${String(err)}`);

package/src/connection.ts

@@ -16,16 +16,28 @@ import type { WsMessage, XgImConfig } from "./types.js";
 
 export type OnMessageCallback = (msg: WsMessage) => void;
 
+/**
+ * CHUNK 载荷：发送端带 seq，便于集群/跨服务按序重排。
+ * - isThinking=true 为思考阶段，seq 从 0 递增（thinkSeq）；
+ * - isThinking=false 为回答阶段，seq 从 0 递增（answerSeq）。
+ */
+export interface ImStreamChunkData {
+    isThinking: boolean;
+    content: string;
+    /** 当前阶段内的序号，think 与 answer 各自从 0 递增 */
+    seq: number;
+}
+
 /**
  * 基于 WebSocket 的流式消息客户端。
  *
  * - start(): 发送 START，等待 ack，返回 msgId。
- * - chunk(): 基于 msgId 发送增量文本。
+ * - chunk(): 基于 msgId 发送增量文本，data 中带 seq（think/answer 阶段分开）。
  * - end(): 发送 END，通知服务端结束本次流式消息。
  */
 export interface ImStreamClient {
     start: (opts: { groupId?: string; toUserId?: string }) => Promise<{ msgId: string }>;
-    chunk: (msgId: string, data: { isThinking: boolean; content: string }) => Promise<void>;
+    chunk: (msgId: string, data: ImStreamChunkData) => Promise<void>;
     end: (msgId: string, reason: string) => Promise<void>;
 }
 
@@ -186,7 +198,7 @@ export function startWebSocket(
                 return;
             }
 
-            // 处理包含 params 的事件（无论是 robotMention 还是普通 message）
+            // 处理包含 params 的事件（robotMention / groupMessage）
             if (parsed.params && (parsed.cmd === "robotMention" || parsed.cmd === "groupMessage")) {
                 if (parsed.cmd === "robotMention") {
                     log.info(`${logPrefix} 📨 robotMention received: groupId=${parsed.params.groupId} msgId=${parsed.params.msgId}`);
@@ -281,18 +293,22 @@ export function startWebSocket(
             return { msgId };
         },
 
-        async chunk(msgId: string, data: { isThinking: boolean; content: string }): Promise<void> {
+        async chunk(msgId: string, data: ImStreamChunkData): Promise<void> {
             const socket = ensureSocketReady();
             const payload = {
                 cmd: "im_stream_msg",
                 params: {
                     event: "CHUNK",
                     msgId,
-                    data,
+                    data: {
+                        isThinking: data.isThinking,
+                        content: data.content,
+                        seq: data.seq,
+                    },
                 },
             };
             if (config.debug) {
-                log.debug?.(`${logPrefix} ⇒ WS CHUNK stream: msgId=${msgId} isThinking=${data.isThinking} length=${data.content.length}`);
+                log.debug?.(`${logPrefix} ⇒ WS CHUNK stream: msgId=${msgId} isThinking=${data.isThinking} seq=${data.seq} length=${data.content.length}`);
             }
             socket.send(JSON.stringify(payload));
         },

package/src/group-history-tool.ts

@@ -18,6 +18,11 @@ const GroupHistoryParams = Type.Object({
     groupId: Type.String({
         description: "群聊 ID，即当前消息来自的群组唯一标识符",
     }),
+    userId: Type.Optional(
+        Type.String({
+            description: "（可选）以哪个用户身份拉取历史消息的 userId，普通对话场景建议传当前发消息用户 ID；若为空则按后台默认身份查询",
+        }),
+    ),
     accountId: Type.Optional(
         Type.String({
             description: "（可选）要使用的 xg_cwork_im 账户下标（数字字符串，默认 0）",
@@ -70,15 +75,24 @@ async function fetchGroupHistory(
     token: string,
     groupId: string,
     limit: number,
+    userId?: string,
 ): Promise<WsMessageParams[]> {
     const url = `${config.baseUrl}/im/message/getLatestMsgListForAI`;
 
+    const params: Record<string, unknown> = {
+        groupId,
+        msgCount: limit,
+    };
+    if (userId) {
+        params.userId = userId;
+    }
+
     const res = await axios.get<{
         resultCode: number;
         message?: string;
         data?: WsMessageParams[];
     }>(url, {
-        params: { groupId, msgCount: limit },
+        params,
         headers: { "access-token": token },
         timeout: 8_000,
     });
@@ -116,7 +130,7 @@ export function buildGroupHistoryTool(config: XgImConfig): AnyAgentTool {
         parameters: GroupHistoryParams,
         async execute(_toolCallId: string, params: Static<typeof GroupHistoryParams>) {
             const limit = params.limit ?? 10;
-            const { groupId, accountId } = params;
+            const { groupId, accountId, userId } = params;
 
             console.log(`[cwork_im][tool] xg_cwork_im_get_group_chat_history called: groupId=${groupId} limit=${limit}`);
 
@@ -136,9 +150,9 @@ export function buildGroupHistoryTool(config: XgImConfig): AnyAgentTool {
             let messages: WsMessageParams[];
             try {
                 const accountConfig = resolveAccountConfig(config, accountId);
-                messages = await fetchGroupHistory(accountConfig, identity.token, groupId, limit);
+                messages = await fetchGroupHistory(accountConfig, identity.token, groupId, limit, userId);
                 console.log(
-                    `[cwork_im][tool] fetched ${messages.length} messages from group ${groupId} using accountId=${accountId ?? "0"}`,
+                    `[cwork_im][tool] fetched ${messages.length} messages from group ${groupId} using accountId=${accountId ?? "0"} userId=${userId ?? "N/A"}`,
                 );
             } catch (err: unknown) {
                 return jsonResult({