@qihoo/tuitui-openclaw-channel 1.0.5 → 1.0.6

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qihoo/tuitui-openclaw-channel",
-  "version": "1.0.5",
+  "version": "1.0.6",
   "maintainers": [
     {
       "name": "huzunjie",
@@ -25,16 +25,6 @@
     "extensions": [
       "./index.ts"
     ],
-    "channel": {
-      "id": "tuitui-openclaw-channel",
-      "label": "TuiTui",
-      "selectionLabel": "TuiTui",
-      "docsPath": "/channels/tuitui",
-      "docsLabel": "tuitui",
-      "blurb": "TuiTui chat integration.",
-      "aliases": [],
-      "order": 90
-    },
     "install": {
       "npmSpec": "@qihoo/tuitui-openclaw-channel",
       "localPath": "extensions/tuitui",

package/src/channel.ts

@@ -5,56 +5,49 @@
  * Supports single chat (text, image, voice, file) and group chat with @mentions.
  */
 import WebSocket from 'ws';
-import type { IncomingMessage, ServerResponse } from 'node:http';
+import { z } from 'zod';
 import {
   DEFAULT_ACCOUNT_ID,
   setAccountEnabledInConfigSection,
   deleteAccountFromConfigSection,
-  registerPluginHttpRoute,
   buildChannelConfigSchema,
 } from 'openclaw/plugin-sdk';
-import { z } from 'zod';
-import type {
-  TuiTuiInboundMessage,
-  TuiTuiOutboundTextMessage,
-  TuiTuiOutboundImageMessage,
-  TuiTuiOutboundAttachmentMessage,
-} from './types';
+import type { TuiTuiInboundMessage } from './types';
 import {
   CHANNEL_ID,
   CHANNEL_NAME,
-  postTuituiMsg,
-  uploadFileToTuiTui,
   buildMessageBody,
   tuituiEmojiReaction,
   checkAccount,
+  sendTextMsg,
+  sendPageMsg,
+  sendMediaMsg,
 } from "./utils";
 
 function resolveAccount(cfg: any, accountId?: string | null) {
-  const channelConfig = cfg?.channels?.[CHANNEL_ID] ?? {};
-  const targetId = accountId ?? DEFAULT_ACCOUNT_ID;
+  const channelConfig = cfg?.channels?.[CHANNEL_ID] || {};
+  const targetId = accountId || DEFAULT_ACCOUNT_ID;
   const acct = targetId === DEFAULT_ACCOUNT_ID ? channelConfig : channelConfig.accounts?.[targetId];
-
   return {
     accountId: targetId,
-    enabled: acct?.enabled ?? false,
+    enabled: acct?.enabled || false,
     appId: acct?.appId as string | undefined,
     appSecret: acct?.appSecret as string | undefined,
-    dmPolicy: acct?.dmPolicy ?? 'pairing',
-    allowFrom: acct?.allowFrom ?? [],
+    dmPolicy: acct?.dmPolicy || 'pairing',
+    allowFrom: acct?.allowFrom || [],
     // 群组策略与白名单、群组级覆盖
     groupPolicy: (acct?.groupPolicy as string | undefined) ?? 'allowlist',
-    groupAllowFrom: Array.isArray(acct?.groupAllowFrom) ? acct.groupAllowFrom : [],
+    groupAllowFrom: acct.groupAllowFrom || [],
     groups: (acct?.groups as Record<string, { requireMention?: boolean, shouldReply?: boolean }> | undefined) ?? {},
   };
 }
 
-function isConfigured(account: any) {
-  return Boolean(
-    String(account?.appId ?? '').trim() &&
-    String(account?.appSecret ?? '').trim()
-  );
-}
+const isConfigured = (account: any)=> Boolean(
+  String(account?.appId ?? '').trim() &&
+  String(account?.appSecret ?? '').trim()
+);
+
+const isToGroup = (chatId: string) => /^\d+$/.test(chatId);
 
 export function createTuiTuiChannelPlugin(apiRuntime: any) {
   return {
@@ -71,7 +64,7 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
     },
 
     capabilities: {
-      chatTypes: ["direct" as const, "group" as const],
+      chatTypes: ['direct' as const, 'group' as const],
       media: true,
       threads: false,
       reactions: false,
@@ -141,16 +134,12 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
         const base = cfg?.channels?.[CHANNEL_ID];
         if (!base) return [];
         const ids = new Set<string>();
-        if (base.enabled !== undefined) {
-          ids.add(DEFAULT_ACCOUNT_ID);
-        }
-        if (base.accounts) {
-          for (const k in base.accounts) ids.add(k);
-        }
+        if (base.enabled) ids.add(DEFAULT_ACCOUNT_ID);
+        if (base.accounts) for (const k in base.accounts) ids.add(k);
         return Array.from(ids);
       },
 
-      resolveAccount: (cfg: any, accountId?: string | null) => resolveAccount(cfg, accountId),
+      resolveAccount,
 
       defaultAccountId: (_cfg: any) => DEFAULT_ACCOUNT_ID,
 
@@ -181,10 +170,10 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
       },
 
       deleteAccount: ({ cfg, accountId }: any) => {
-        if (accountId === DEFAULT_ACCOUNT_ID) {
+        return accountId === DEFAULT_ACCOUNT_ID
           // For default account, we don't delete the entire config
           // Instead, we disable it and clear sensitive fields
-          return {
+          ? {
             ...cfg,
             channels: {
               ...cfg.channels,
@@ -195,23 +184,22 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
                 appSecret: undefined,
               },
             },
-          };
-        }
-        // For named accounts, use the standard delete function
-        return deleteAccountFromConfigSection({
-          cfg,
-          sectionKey: CHANNEL_ID,
-          accountId,
-          clearBaseFields: [
-            'appId',
-            'appSecret',
-            'dmPolicy',
-            'allowFrom',
-            'groupPolicy',
-            'groupAllowFrom',
-            'groups',
-          ],
-        });
+          }
+          // For named accounts, use the standard delete function
+          : deleteAccountFromConfigSection({
+            cfg,
+            sectionKey: CHANNEL_ID,
+            accountId,
+            clearBaseFields: [
+              'appId',
+              'appSecret',
+              'dmPolicy',
+              'allowFrom',
+              'groupPolicy',
+              'groupAllowFrom',
+              'groups',
+            ],
+          });
       },
     },
 
@@ -234,12 +222,12 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
 
     security: {
       resolveDmPolicy: ({ cfg, accountId, account }: { cfg: any; accountId?: string | null; account?: any; }) => {
-        const _account = account ?? resolveAccount(cfg, accountId);
-        const _accountId = accountId ?? _account.accountId ?? DEFAULT_ACCOUNT_ID;
+        account = account || resolveAccount(cfg, accountId);
+        const accId = accountId ?? account.accountId ?? DEFAULT_ACCOUNT_ID;
         let allowFromPath =`channels.${CHANNEL_ID}.`;
-        if (_accountId !== DEFAULT_ACCOUNT_ID) allowFromPath += `accounts.${_accountId}.`;
+        if (accId !== DEFAULT_ACCOUNT_ID) allowFromPath += `accounts.${accId}.`;
 
-        const policy = _account.dmPolicy ?? 'pairing';
+        const policy = account.dmPolicy ?? 'pairing';
         // dmPolicy semantics:
         // - open: always allow everyone (["*"]), ignore allowFrom values.
         // - pairing: unknown senders get a pairing code; approvals add to allowFrom store.
@@ -247,7 +235,7 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
         // - disabled: block all DMs.
         return {
           policy,
-          allowFrom: policy === 'open' ? ['*'] : (_account.allowFrom ?? []),
+          allowFrom: policy === 'open' ? ['*'] : (account.allowFrom ?? []),
           policyPath: `${allowFromPath}dmPolicy`,
           allowFromPath,
           approveHint: `openclaw pairing approve ${CHANNEL_ID} <code>`,
@@ -274,144 +262,45 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
       deliveryMode: 'gateway' as const,
       textChunkLimit: 2000,
 
-      sendText: async ({ cfg, to, text, accountId, account, log }: any) => {
-        const _account = account ?? resolveAccount(cfg, accountId);
-        checkAccount(_account, 'send text');
+      sendText: async ({ cfg, to, text, accountId, account }: any) => {
+        account = account || resolveAccount(cfg, accountId);
+        checkAccount(account, 'send text');
         
-        const toStr = String(to || '').trim();
+        const chatId = String(to || '').trim();
         // Determine if this is a group message based on 'to' being all digits (group) or not (direct)
-        const isGroup = /^\d+$/.test(toStr);
-
-        // Format message according to TuiTui's required structure
-        const payload: TuiTuiOutboundTextMessage = {
-          tousers: isGroup ? [] : [toStr],
-          togroups: isGroup ? [toStr] : [],
-          at: [],
-          msgtype: 'text',
-          text: { content: text },
-        };
-
-        log?.info?.(
-          `[${CHANNEL_ID}] sendText  - 
-          accountId=${accountId ?? 'default'},
-          to=${toStr},
-          target_users: [${payload.tousers.join(",")}],
-          target_groups: [${payload.togroups.join(",")}],
-          isGroup: ${isGroup},
-          textLength=${String(text ?? '').length},
-          text: ${text}`
-        );
+        await sendTextMsg(account, chatId, isToGroup(chatId), text);
 
-        await postTuituiMsg(_account, payload, 'tuitui.send.text', log);
-
-        return { channel: CHANNEL_ID, messageId: `tt-${Date.now()}`, chatId: toStr };
+        return { channel: CHANNEL_ID, messageId: `tuitui-text-${Date.now()}`, chatId };
       },
 
       sendCustom: async ({ cfg, to, payload, accountId, account, chatType, groupId, log }: any) => {
-        const _account = account ?? resolveAccount(cfg, accountId);
-        checkAccount(_account, 'send custom message');
+        account = account || resolveAccount(cfg, accountId);
+        checkAccount(account, 'send custom message');
 
         // If it's a page message, we need to construct it
         if (payload?.msgtype !== 'page') {
           throw new Error(`[${CHANNEL_ID}] unsupported custom message type: ${payload?.msgtype}`);
         }
 
-        const toStr = String(to || '').trim();
+        const chatId = String(to || '').trim();
         // Determine if this is a group message
         // WORKAROUND: OpenClaw core doesn't pass chatType/groupId to sendPayload.
         // If `to` is a numeric string and chatType/groupId are undefined, assume it's a group.
-        const toIsNum = /^\d+$/.test(toStr);
-        const isGroup = chatType === 'group' || groupId || (toIsNum && !chatType);
-        const toGroupId = groupId || (isGroup ? toStr : undefined);
-        const toUserId = isGroup ? undefined : toStr;
-
-        const _payload: any = {
-          tousers: payload.tousers || (toUserId ? [toUserId] : []),
-          togroups: payload.togroups || (toGroupId ? [toGroupId] : []),
-          msgtype: 'page',
-          page: { ...payload.page }
-        };
-
-        log?.info?.(
-          `[${CHANNEL_ID}] sending page to TuiTui - 
-          target_users: [${_payload.tousers.join(",")}], 
-          target_groups: [${_payload.togroups.join(",")}], 
-          chatType: ${chatType ?? 'direct'},
-          account=${accountId ?? 'default'},
-          chatType=${chatType ?? 'direct'},
-          to=${toStr},
-          groupId=${groupId ?? '-'}`,
-        );
-
-        await postTuituiMsg(_account, _payload, 'tuitui.send.page', log);
+        const isGroup = chatType === 'group' || !!groupId || (isToGroup(chatId) && !chatType);
+        await sendPageMsg(account, chatId, isGroup, payload.page);
 
-        return { channel: CHANNEL_ID, messageId: `tt-${Date.now()}`, chatId: toStr };
+        return { channel: CHANNEL_ID, messageId: `tuitui-page-${Date.now()}`, chatId };
       },
 
       sendMedia: async ({ cfg, to, mediaUrl, accountId, account, log }: any) => {
-        const _account = account ?? resolveAccount(cfg, accountId);
-        checkAccount(_account, 'send media');
+        account = account || resolveAccount(cfg, accountId);
+        checkAccount(account, 'send media');
 
-        const toStr = String(to || '').trim();
+        const chatId = String(to || '').trim();
         // Determine if this is a group message based on 'to' being all digits (group) or not (direct)
-        const isGroup = /^\d+$/.test(toStr);
-        const toGroupId = isGroup ? toStr : undefined;
-        const toUserId = isGroup ? undefined : toStr;
-
-        // Detect image/file by URL pattern first; fallback to upload API type auto-detection when needed.
-        // NOTE: relying on `mediaUrl.includes("image")` is too broad and can misclassify files.
-        const isImageByExt = /\.(jpg|jpeg|png|gif|webp|bmp|svg)(?:$|[?#])/i.test(mediaUrl);
-        const isDataUrlImage = /^data:image\//i.test(mediaUrl);
-        const isImage = isImageByExt || isDataUrlImage;
-        const uploadType = isImage ? 'image' : 'file';
-
-        log?.debug?.(
-          `[${CHANNEL_ID}] sendMedia classify 
-          account=${accountId ?? 'default'},
-          to=${toStr},
-          isGroup=${isGroup},
-          mediaUrl=${mediaUrl},
-          isImageByExt=${isImageByExt},
-          isDataUrlImage=${isDataUrlImage},
-          uploadType=${uploadType}`,
-        );
-
-        const media_id = await uploadFileToTuiTui(mediaUrl, _account, uploadType);
-        if (!media_id) {
-          log?.error?.(`[${CHANNEL_ID}] sendMedia upload failed to get media_id from TuiTui for mediaUrl: ${mediaUrl}`);
-          return;
-        }
-        log?.debug?.(`[${CHANNEL_ID}] sendMedia upload done type=${uploadType} media_id=${media_id}`);
-
-        // Keep outbound msgtype consistent with upload type.
-        // 群消息：togroups 填群ID，tousers 是空数组；私聊：tousers 填 to；均不设置 at
-        const payload: any = {
-          tousers: toUserId ? [toUserId] : [],
-          togroups: toGroupId ? [toGroupId] : [],
-          msgtype: uploadType === 'image' ? 'image' : 'attachment',
-          image: { media_id },
-        };
+        await sendMediaMsg(account, chatId, isToGroup(chatId), mediaUrl);
 
-        log?.info?.(
-          `[${CHANNEL_ID}] sending media to TuiTui - 
-          target_users: [${payload.tousers.join(',')}],
-          target_groups: [${payload.togroups.join(',')}],
-          type: ${payload.msgtype},
-          isGroup=${isGroup},
-          msgtype=${payload.msgtype},
-          account=${accountId ?? 'default'},
-          to=${toStr},
-          isGroup=${isGroup},
-          payload=${JSON.stringify(payload)},
-          toGroupId=${toGroupId},
-          toUserId=${toUserId},
-          uploadType=${uploadType},
-          media_id=${media_id}`
-        );
-
-        await postTuituiMsg(_account, payload, 'tuitui.send.media', log);
-
-        return { channel: CHANNEL_ID, messageId: `tt-${Date.now()}`, chatId: toStr };
+        return { channel: CHANNEL_ID, messageId: `tuitui-media-${Date.now()}`, chatId };
       },
     },
 
@@ -610,16 +499,7 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
               }
 
               if (!normalizedGroupAllowFrom.includes(String(groupId))) {
-                log?.info?.(`[${CHANNEL_ID}] Group ${groupId} not allowed`);
-                
-                const payload: TuiTuiOutboundTextMessage = {
-                  tousers: [],
-                  togroups: [groupId],
-                  at: [],
-                  msgtype: "text",
-                  text: { content: `当前openclaw群聊策略为白名单，需要主人在群白名单(Group Allow From)增加当前群ID：\n${groupId}` },
-                };
-                await postTuituiMsg(account, payload, 'tuitui.groupPolicy.reply', log);
+                await sendTextMsg(account, groupId, true, `当前openclaw群聊策略为白名单，需要主人在群白名单(Group Allow From)增加当前群ID：\n${groupId}`, 'tuitui.groupPolicy.reply');
                 return;
               }
 
@@ -696,21 +576,11 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
                           apiRuntime?.channel?.pairing?.buildPairingReply?.({
                             channel: CHANNEL_ID,
                             code: req.code,
-                          }) ?? 'Pairing required. Ask the bot owner to approve.';
+                          }) ?? '需要进行配对。请让机器人所有者进行批准。';
 
                         // tousers 使用 userAccount（推推用户账号）
                         const toUname = String(userAccount || '').trim();
-                        log?.debug?.(
-                          `[${CHANNEL_ID}] pairing.reply target=${toUname}`,
-                        );
-                        const payload: TuiTuiOutboundTextMessage = {
-                          tousers: toUname ? [toUname] : [],
-                          togroups: [],
-                          at: [],
-                          msgtype: 'text',
-                          text: { content: replyText },
-                        };
-                        await postTuituiMsg(account, payload, 'tuitui.pairing.reply', log);
+                        await sendTextMsg(account, toUname, false, replyText, 'tuitui.pairing.reply');
                       }
                     } catch (err) {
                       log?.warn?.(`[${CHANNEL_ID}] pairing flow failed for ${senderForPolicy}: ${String(err)}` );
@@ -778,7 +648,6 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
             if (replyToId) msgCtx.ReplyToId = replyToId;
 
             // Dispatch via the SDK's buffered block dispatcher
-            let sentCount = 0;
             if (!apiRuntime) {
               log?.error?.(`[${CHANNEL_ID}] TuiTuiRuntime error，未能发送回复。`);
               return;
@@ -800,8 +669,6 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
                     [key: string]: any;
                   };
                 }) => {
-                  // mark that we received a deliver call (attempt to send reply)
-                  sentCount++;
 
                   // 如果设置了 suppressReply 标志，则不发送回复
                   if (suppressReply) {
@@ -809,125 +676,33 @@ export function createTuiTuiChannelPlugin(apiRuntime: any) {
                     return;
                   }
 
+                  const chatTarget = chatTypeIsGroup ? groupId : userAccount;
                   // Handle custom messages (e.g., page messages)
                   if (payload.custom) {
-                    try {
-                      const customPayload = payload.custom;
-
-                      // Handle page message type
-                      if (customPayload.msgtype === 'page' && customPayload.page) {
-                        const pagePayload: any = {
-                          tousers: customPayload.tousers || (chatTypeIsDirect && userAccount ? [userAccount] : []),
-                          togroups: customPayload.togroups || (chatTypeIsGroup && groupId ? [groupId] : []),
-                          msgtype: 'page',
-                          page: customPayload.page,
-                        };
-
-                        log?.info?.(
-                          `[${CHANNEL_ID}] sending page reply to TuiTui - 
-                          target_users: [${pagePayload.tousers.join(',')}],
-                          target_groups: [${pagePayload.togroups.join(',')}]
-                          chatType=${chatType},
-                          tousers=${JSON.stringify(pagePayload.tousers)},
-                          togroups=${JSON.stringify(pagePayload.togroups)},
-                          title=${String(pagePayload?.page?.title ?? '')}`,
-                        );
-
-                        await postTuituiMsg(account, pagePayload, 'tuitui.deliver.page', log);
-                      } else {
-                        log?.warn?.(`[${CHANNEL_ID}] Unsupported custom message type: ${customPayload.msgtype}`);
-                      }
-                    } catch (e) {
-                      log?.error?.(`[${CHANNEL_ID}] Error sending custom reply to TuiTui: ${e}`);
+                    const { msgtype, page, tousers, togroups } = payload.custom;
+                    // Handle page message type
+                    if (msgtype === 'page' && page) {
+                      await sendPageMsg(account, chatTarget, chatTypeIsGroup, page, 'tuitui.deliver.page', tousers, togroups);
+                      return;
                     }
+                    log?.warn?.(`[${CHANNEL_ID}] Unsupported custom message type: ${msgtype}`);
                     return;
                   }
-
                   if (payload.mediaUrl || payload.mediaUrls?.length) {
                     // Handle media messages
                     const mediaUrl = payload.mediaUrl || payload.mediaUrls?.[0];
                     if (mediaUrl) {
-                      try {
-                        checkAccount(account, 'send media');
-
-                        // Check if mediaUrl looks like an image
-                        const isImage = /\.(jpg|jpeg|png|gif|webp|bmp)$/i.test(mediaUrl);
-
-                        const media_id = await uploadFileToTuiTui(mediaUrl, account, isImage ? 'image' : 'file');
-                        if (!media_id) {
-                          log?.error?.(`[${CHANNEL_ID}] sendMedia upload failed to get media_id from TuiTui for mediaUrl: ${mediaUrl}`);
-                          return;
-                        }
-
-                        // Build outbound message based on chat type
-                        // 群消息：togroups 填群ID，at 是 userAccount 的字符串值，tousers 是空数组
-                        // 私聊消息：tousers 填 userAccount，at 不存在，togroups 不存在
-                        const _baseOutboundMsg = {
-                          tousers: chatTypeIsGroup ? [] : userAccount ? [userAccount] : [],
-                          togroups: chatTypeIsGroup && groupId ? [groupId] : [],
-                          at: chatTypeIsGroup && userAccount ? userAccount : undefined,
-                        };
-                        const outboundMsg: TuiTuiOutboundImageMessage | TuiTuiOutboundAttachmentMessage =
-                          isImage
-                            ? { ..._baseOutboundMsg, msgtype: 'image', image: { media_id } }
-                            : { ..._baseOutboundMsg, msgtype: 'attachment',  attachment: { media_id } };
-
-                        log?.info?.(
-                          `[${CHANNEL_ID}] sending media reply to TuiTui - 
-                          target_users: [${outboundMsg?.tousers?.join(",")}],
-                          target_groups: [${outboundMsg?.togroups?.join(",")}],
-                          type: ${outboundMsg.msgtype},
-                          to=${JSON.stringify(outboundMsg.tousers)},
-                          group=${JSON.stringify(outboundMsg.togroups)},
-                          msgtype=${outboundMsg.msgtype},
-                          chatType=${chatType},
-                          userAccount=${userAccount},
-                          groupId=${groupId},
-                          isImage=${isImage},
-                          outboundMsg.tousers=${JSON.stringify(outboundMsg.tousers)},
-                          outboundMsg.togroups=${JSON.stringify(outboundMsg.togroups)},
-                          outboundMsg.at=${outboundMsg.at}`
-                        );
-
-                        await postTuituiMsg(account, outboundMsg, 'tuitui.deliver.media', log);
-                      } catch (e) {
-                        log?.error?.(`[${CHANNEL_ID}] Error sending media reply to TuiTui: ${e}`);
-                      }
-                    }
-                  } else if (payload.text || payload.body) {
-                    // Handle text messages
-                    const replyText = payload?.text ?? payload?.body;
-                    if (replyText) {
-                      try {
-                        // Build outbound message based on chat type
-                        // tousers 使用 userAccount（推推用户账号）
-                        // at 使用 userAccount（群聊 @ 用户）
-                        // 群消息回复时不再使用 reference_msgid 避免并发时引用错乱，依靠 @ 来提醒用户
-                        const outboundMsg: TuiTuiOutboundTextMessage = {
-                          tousers: chatTypeIsDirect && userAccount ? [userAccount] : [],
-                          togroups: chatTypeIsGroup && groupId ? [groupId] : [],
-                          at: chatTypeIsGroup && userAccount ? [userAccount] : [],
-                          msgtype: 'text',
-                          text: { content: replyText },
-                        };
-
-                        log?.info?.(
-                          `[${CHANNEL_ID}] sending text reply to TuiTui - 
-                          target_users: [${outboundMsg.tousers.join(',')}],
-                          target_groups: [${outboundMsg.togroups.join(',')}]
-                          chatType=${chatType},
-                          tousers=${JSON.stringify(outboundMsg.tousers)},
-                          togroups=${JSON.stringify(outboundMsg.togroups)},
-                          at=${JSON.stringify((outboundMsg as any).at ?? [])},
-                          userAccount=${String(userAccount)},
-                          groupId=${String(groupId)}`,
-                        );
-
-                        await postTuituiMsg(account, outboundMsg, 'tuitui.deliver.text', log);
-                      } catch (e) {
-                        log?.error?.(`[${CHANNEL_ID}] Error sending reply to TuiTui: ${e}`);
-                      }
+                      await sendMediaMsg(account, chatTarget, chatTypeIsGroup, mediaUrl, 'tuitui.deliver.media');
                     }
+                    return;
+                  }
+                  // Handle text messages
+                  const replyText = payload?.text || payload?.body;
+                  if (replyText) {
+                    // at 使用 userAccount（群聊 @ 用户）
+                    const atList = chatTypeIsGroup && userAccount ? [userAccount] : [];
+                    // 群消息回复时不再使用 reference_msgid 避免并发时引用错乱，依靠 @ 来提醒用户
+                    await sendTextMsg(account, chatTarget, chatTypeIsGroup, replyText, 'tuitui.deliver.text', atList);
                   }
                 },
                 onReplyStart: () => {

package/src/types.ts

@@ -64,7 +64,7 @@ export interface TuiTuiOutboundLinkMessage {
 export interface TuiTuiOutboundImageMessage {
   tousers?: string[];
   togroups?: string[];
-  at?: string;
+  at?: string[];
   msgtype: 'image';
   image: { media_id: string };
 }
@@ -72,37 +72,31 @@ export interface TuiTuiOutboundImageMessage {
 export interface TuiTuiOutboundAttachmentMessage {
   tousers?: string[];
   togroups?: string[];
-  at?: string;
+  at?: string[];
   msgtype: 'attachment';
   attachment: { media_id: string };
 }
 
+export interface TuiTuiOutboundPageMessagePage {
+  title: string;
+  summary?: string;
+  content: string;
+  image?: string;
+  format?: 'html';
+  privilege?: 'specific' | 'scope' | 'corp' | 'any';
+  delims_left?: string;
+  delims_right?: string;
+  kv?: Record<string, string>;
+  default_value?: string;
+  debug?: boolean;
+}
 export interface TuiTuiOutboundPageMessage {
   tousers: string[];
   togroups: string[];
   msgtype: 'page';
-  page: {
-    title: string;
-    summary?: string;
-    content: string;
-    image?: string;
-    format?: 'html';
-    privilege?: 'specific' | 'scope' | 'corp' | 'any';
-    delims_left?: string;
-    delims_right?: string;
-    kv?: Record<string, string>;
-    default_value?: string;
-    debug?: boolean;
-  };
+  page: TuiTuiOutboundPageMessagePage;
 }
 
-export type TuiTuiOutboundMessage =
-  | TuiTuiOutboundTextMessage
-  | TuiTuiOutboundLinkMessage
-  | TuiTuiOutboundImageMessage
-  | TuiTuiOutboundAttachmentMessage
-  | TuiTuiOutboundPageMessage;
-
 export interface TuiTuiMediaUploadResponse {
   errcode: number;
   errmsg: string;

package/src/utils.ts

@@ -1,9 +1,17 @@
-import { createHash } from 'node:crypto';
 import { readFileSync, existsSync, statSync } from 'node:fs';
-import type { IncomingMessage } from 'node:http';
 import { basename } from 'node:path';
 import { fetchWithSsrFGuard } from 'openclaw/plugin-sdk';
-import type { TuiTuiMessageData, TuiTuiMediaUploadResponse, TuiTuiSingleEmojiReactionTarget, TuiTuiGroupEmojiReactionTarget } from './types';
+import type { 
+  TuiTuiMessageData,
+  TuiTuiMediaUploadResponse,
+  TuiTuiSingleEmojiReactionTarget,
+  TuiTuiGroupEmojiReactionTarget,
+  TuiTuiOutboundTextMessage,
+  TuiTuiOutboundPageMessage,
+  TuiTuiOutboundPageMessagePage,
+  TuiTuiOutboundImageMessage,
+  TuiTuiOutboundAttachmentMessage
+} from './types';
 
 /* 一些常量配置 */
 export const CHANNEL_ID = 'tuitui';
@@ -41,11 +49,11 @@ function _fetch(opts: any): Promise<any> {
   return fetchWithSsrFGuard({
     //url: fileSrc,
     policy: TUITUI_SSRF_POLICY,
-    //auditContext: "tuitui.media.download",
+    //auditCtx: "tuitui.media.download",
     ...opts,
   })
 }
-function _fetchJson(url: string, json: any, auditContext: string): Promise<any> {
+function _fetchJson(url: string, json: any, auditCtx: string): Promise<any> {
   return _fetch({
     url,
     init: {
@@ -53,42 +61,31 @@ function _fetchJson(url: string, json: any, auditContext: string): Promise<any>
       headers: { 'Content-Type': 'application/json' },
       body: JSON.stringify(json),
     },
-    auditContext,
+    auditCtx,
   });
 }
-export async function postTuituiMsg(account: any, json: any, auditContext: string, log: any): Promise<any> {
+export async function postTuituiMsg(account: any, json: any, auditCtx: string): Promise<any> {
   const { appId: appid, appSecret: secret } = account;
   const { response, release } = await _fetchJson(
     addParams2Url('https://im.live.360.cn:8282/robot/message/custom/send', { appid, secret }),
     json,
-    auditContext,
+    auditCtx,
   );
   try {
     const bodyText = await response.text();
-    let parsed: any = null;
-    try {
-      parsed = bodyText ? JSON.parse(bodyText) : null;
-    } catch(err) {
-      parsed = null;
-    }
+    const parsed =  JSON.parse(bodyText);
 
-    log?.debug?.(
-      `[${CHANNEL_ID}] ${auditContext} response status=${response.status} ok=${response.ok} body=${bodyText || '<empty>'}`,
-    );
+    console.debug(`[${CHANNEL_ID}] ${auditCtx} postTuituiMsg response status=${response.status} ok=${response.ok} body=${bodyText || '<empty>'}`);
 
     if (!response.ok) {
-      throw new Error(
-        `[${CHANNEL_ID}] ${auditContext} Failed (response.ok unexpected): ${response.status} ${response.statusText}; body=${bodyText || '<empty>'}`,
-      );
+      throw new Error(`postTuituiMsg Failed (response.ok unexpected): ${response.status} ${response.statusText}; body=${bodyText || '<empty>'}`);
     }
 
-    if (parsed && typeof parsed.errcode === 'number' && parsed.errcode !== 0) {
-      throw new Error(
-        `[${CHANNEL_ID}] ${auditContext} Failed (errcode unexpected): errcode=${parsed.errcode} errmsg=${parsed.errmsg ?? 'Unknown error'}`,
-      );
+    if (Number(parsed?.errcode) !== 0) {
+      throw new Error(`postTuituiMsg Failed (errcode unexpected): errcode=${parsed.errcode} errmsg=${parsed.errmsg ?? 'Unknown error'}`);
     }
   } catch(err) {
-    console.error(`[${CHANNEL_ID}] postTuituiMsg error:`, err, `\njson: ${JSON.stringify(json)}`);
+    console.error(`[${CHANNEL_ID}] ${auditCtx} postTuituiMsg error:`, err, `\njson: ${JSON.stringify(json)}`);
   } finally {
     await release();
   }
@@ -148,7 +145,7 @@ export async function uploadFileToTuiTui(fileSrc: string, account: any, type: 'i
   }
   // HTTP/HTTPS URL
   else if (/^https?\:/.test(fileSrc)) {
-    const { response, release } = await _fetch({ url: fileSrc, auditContext: 'tuitui.media.download' });
+    const { response, release } = await _fetch({ url: fileSrc, auditCtx: 'tuitui.media.download' });
     try {
       if (!response.ok) {
         throw new Error(`[${CHANNEL_ID}] Failed to download media from ${fileSrc}: ${response.status}`);
@@ -201,7 +198,7 @@ export async function uploadFileToTuiTui(fileSrc: string, account: any, type: 'i
   const { response, release } = await _fetch({
     url: addParams2Url('https://im.live.360.cn:8282/robot/media/upload', { appid, secret, type }),
     init: { method: "POST", body },
-    auditContext: "tuitui.media.upload",
+    auditCtx: "tuitui.media.upload",
   });
   try {
     if (!response.ok) {
@@ -287,11 +284,11 @@ export async function tuituiEmojiReaction(
   targetIsGroup: boolean,
   msgid: string,
   emoji: string
-): Promise<string> {
+): Promise<void> {
   const payload = {
     msgtype: 'emoji_reaction',
-    tousers:[] as TuiTuiSingleEmojiReactionTarget[],
-    togroups:[] as TuiTuiGroupEmojiReactionTarget[],
+    tousers: [] as TuiTuiSingleEmojiReactionTarget[],
+    togroups: [] as TuiTuiGroupEmojiReactionTarget[],
     emoji_reaction: { emoji, cancel: false},
   };
   if(targetIsGroup) {
@@ -312,6 +309,83 @@ export async function tuituiEmojiReaction(
   } finally {
     await release();
   }
+}
+
+function getTargets(chatId: string, isGroup: boolean): { tousers: string[]; togroups: string[] } {
+  const tousers: string[] = [];
+  const togroups: string[] = [];
+  (isGroup ? togroups : tousers).push(chatId);
+  return { tousers, togroups };
+}
+
+export async function sendTextMsg(
+  account: any,
+  target: string | undefined,
+  isGroup: boolean,
+  content: string,
+  auditCtx: string = 'tuitui.send.text',
+  atList?: string[],
+): Promise<void> {
+  if (!target) return console.error(`[${CHANNEL_ID}] sendTextMsg Error ${auditCtx}: Missing "target"`);
+  // Format message according to TuiTui's required structure
+  const msg: TuiTuiOutboundTextMessage = {
+    msgtype: 'text',
+    ...getTargets(target, isGroup),
+    at: atList || [],
+    text: { content },
+  };
+  console.log(`[${CHANNEL_ID}] sendTextMsg ${auditCtx} - `, msg);
+  await postTuituiMsg(account, msg, auditCtx);
+}
+
+export async function sendPageMsg(
+  account: any,
+  target: string | undefined,
+  isGroup: boolean,
+  page: TuiTuiOutboundPageMessagePage,
+  auditCtx: string = 'tuitui.send.page',
+  tousers?: string[],
+  togroups?: string[],
+): Promise<void> {
+  if (!target) return console.error(`[${CHANNEL_ID}] sendPageMsg Error ${auditCtx}: Missing "target"`);
+  const targets = getTargets(target, isGroup);
+  tousers = tousers || targets.tousers;
+  togroups = togroups || targets.togroups;
+  const msg: TuiTuiOutboundPageMessage = {
+    msgtype: 'page',
+    tousers,
+    togroups,
+    page: { ...(page || {})}
+  };
+  console.log(`[${CHANNEL_ID}] sendPageMsg ${auditCtx} - `, msg);
+  await postTuituiMsg(account, msg, auditCtx);
+}
+
+export async function sendMediaMsg(
+  account: any,
+  target: string | undefined,
+  isGroup: boolean,
+  mediaUrl: string,
+  auditCtx: string = 'tuitui.send.media',
+): Promise<void> {
+  if (!target) return console.error(`[${CHANNEL_ID}] sendMediaMsg Error ${auditCtx}: Missing "target"`);
+  // Check if mediaUrl looks like an image
+  const isImage = /^data:image\//i.test(mediaUrl) || /\.(jpg|jpeg|png|gif)(?:$|[?#])/i.test(mediaUrl);
+  const mediaType = isImage ? 'image' : 'file';
+
+  const media_id = await uploadFileToTuiTui(mediaUrl, account, mediaType);
+  if (!media_id) {
+    console.error(`[${CHANNEL_ID}] uploadFileToTuiTui failed ${auditCtx}, {mediaUrl: ${mediaUrl}, mediaType: ${mediaType}}`);
+    return;
+  }
+
+  const targets = getTargets(target, isGroup);
+  const msg: TuiTuiOutboundImageMessage | TuiTuiOutboundAttachmentMessage =
+    isImage
+      ? { ...targets, msgtype: 'image', image: { media_id } }
+      : { ...targets, msgtype: 'attachment', attachment: { media_id } };
+
+  console.log(`[${CHANNEL_ID}] sendMediaMsg ${auditCtx} - `, msg);
 
-  return '';
+  await postTuituiMsg(account, msg, auditCtx);
 }