@qihoo/tuitui-openclaw-channel 1.0.27 → 1.0.29

package/README.md

@@ -27,7 +27,7 @@
 
 ## 安装与配置指南
 
-> 最小兼容版本为 `OpenClaw 2026.3.13`、最高测试版本 `OpenClaw 2026.4.9`。
+> 最小兼容版本为 `OpenClaw 2026.3.13`。
 
 龙虾+推推插件配置指南
 

package/openclaw.plugin.json

@@ -131,7 +131,7 @@
           "advanced": true
         },
         "monitorEnabled": {
-          "help": "是否开启工作状态监控上报（默认 false）。开启后，所有 Agent 事件的完整原始数据将实时上报到监控接口。",
+          "help": "是否开启agent事件信息上报（默认 false）。修改后必须重启网关才能生效。",
           "order": 17,
           "advanced": true
         },
@@ -185,7 +185,7 @@
           "advanced": true
         },
         "accounts.*.monitorEnabled": {
-          "help": "是否开启工作状态监控上报（默认 false）。",
+          "help": "是否开启agent事件信息上报（默认 false）。修改后必须重启网关才能生效。",
           "order": 311,
           "advanced": true
         }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@qihoo/tuitui-openclaw-channel",
-  "version": "1.0.27",
+  "version": "1.0.29",
   "maintainers": [
     {
       "name": "huzunjie",

package/skills/tuitui-im-read/SKILL.md

@@ -17,19 +17,19 @@ description: |
 
 ---
 
-## 工具：tuitui_im_get_messages
+## 工具: tuitui_im_get_messages
 
 ### 参数说明
 
 | 参数 | 类型 | 必填 | 说明 |
 |------|------|------|------|
-| `chatId` | string | ✅ | 聊天 ID。单聊填对方的 tuitui account，群聊填群 ID |
-| `chatType` | string | ✅ | 聊天类型：单聊填 `direct`，群聊填 `group` |
-| `relativeTime` | string | ❌ | 相对时间范围：today / yesterday / day_before_yesterday / this_week / last_week / this_month / last_month / last_{N}_{unit}（unit: minutes/hours/days）。与 `startTime`/`endTime` 互斥 |
+| `chatId` | string | ✅ | 聊天 ID。单聊填对方的 tuitui account，群聊填群ID，频道填频道ID |
+| `chatType` | string | ✅ | 聊天类型：单聊填 `direct`，群聊填 `group`, 频道填 `channel` |
+| `relativeTime` | string | ❌ | 相对时间范围：today / yesterday / day_before_yesterday / last_{N}_{unit}（unit: minutes/hours/days/months）。与 `startTime`/`endTime` 互斥 |
 | `startTime` | string | ❌ | 起始时间，ISO 8601 格式，如 `2026-02-27T00:00:00+08:00`。不填默认从最早开始。与 `relativeTime` 互斥 |
 | `endTime` | string | ❌ | 结束时间，ISO 8601 格式，如 `2026-02-27T23:59:59+08:00`。不填默认到当前时间。与 `relativeTime` 互斥 |
-| `limit` | number | ❌ | 每页条数，范围 1~100，默认 100 |
-| `cursor` | string | ❌ | 分页游标，首次调用填 `"0"`，翻页时传上次返回的 `cursor` |
+| `limit` | number | ❌ | 每页条数，范围 1~100，单聊群聊默认 100，频道默认20 |
+| `cursor` | string | ❌ | 分页游标，首次调用填 `"0"`，翻页时传上次返回的 `cursor`, 带有cursor时，必须要有relativeTime或者startTime参数 |
 | `orderAsc` | boolean | ❌ | 排序方向，`true` 正序（从旧到新），`false` 逆序（从新到旧，默认） |
 
 ### 返回结构
@@ -43,16 +43,7 @@ description: |
   "current_time": "2026-03-21 10:00:00",
   "msgs": [
     {
-      "user_account": "zhangsan",
-      "user_name": "张三",
-      "msg_time": "2026-01-03 15:42:44",
-      "msg_type": "text",
-      "text": "消息内容",
-      "images": [],
-      "group_id": "group_abc",
-      "group_name": "某群",
-      "at_me": false,
-      "ref": null
+      //...
     }
   ]
 }
@@ -65,15 +56,6 @@ description: |
 | `current_time` | 当前服务器时间，格式 `YYYY-MM-DD HH:MM:SS`，辅助理解消息的相对时间 |
 | `has_more` | `true` 时说明还有更多数据，可用返回的 `cursor` 继续翻页 |
 | `msgs` | 消息列表，空数组表示该时间段内没有消息 |
-| `msgs[].user_account` | 发送者账号 |
-| `msgs[].user_name` | 发送者显示名称 |
-| `msgs[].msg_time` | 消息时间，格式 `YYYY-MM-DD HH:MM:SS` |
-| `msgs[].msg_type` | 消息类型：`text` / `image` / `mixed` / `voice` / `file` |
-| `msgs[].text` | 文本内容（`msg_type` 为 `text` / `mixed` 时有值） |
-| `msgs[].images` | 图片 URL 列表（`msg_type` 为 `image` / `mixed` 时有值） |
-| `msgs[].file` | 文件信息 `{ name, url, file_id }`（`msg_type` 为 `file` 时有值） |
-| `msgs[].at_me` | 是否 @ 了机器人（群聊） |
-| `msgs[].ref` | 引用/回复的原消息，无引用时为 `null` |
 
 ---
 
@@ -81,7 +63,8 @@ description: |
 
 ### 1. 时间范围：确保消息覆盖完整
 
-- 用户说"今天"、"最近"等相对时间时，自主推算对应的 `startTime` / `endTime`（ISO 8601，+08:00 时区）
+- 用户说"今天"、"最近一周"等相对时间时，应该优先使用 relativeTime 参数，例如 今天=today  过去一周=last_7_days 过去一个月=last_31_days
+- 只有用户明确的说日期时，才计算并使用 `startTime` / `endTime` 字段（ISO 8601，+08:00 时区）
 - 不确定范围时适当放宽，宁可多拉再过滤
 
 ### 2. 分页：根据需要翻页获取更多结果
@@ -107,19 +90,17 @@ description: |
 }
 ```
 
-### 场景 2：获取某时间段内的单聊消息
+### 场景 2：获取最近一周的某群聊消息
 
 ```json
 {
-  "chatId": "zhangsan",
-  "chatType": "direct",
-  "startTime": "2026-03-01T00:00:00+08:00",
-  "endTime": "2026-03-01T23:59:59+08:00",
-  "orderAsc": true
+  "chatId": "4511334567",
+  "chatType": "group",
+  "relativeTime": "last_7_days"
 }
 ```
 
-### 场景 3：分页获取更多消息
+### 场景 3：获取最近一周的某群聊消息时出现分页后，继续分页获取更多消息
 
 第一次调用返回 `has_more: true` 和 `cursor: "xxx"`，继续获取：
 
@@ -127,10 +108,20 @@ description: |
 {
   "chatId": "4511334567",
   "chatType": "group",
+  "relativeTime": "last_7_days",
   "cursor": "xxx"
 }
 ```
 
+### 场景 4：获取某频道最新消息
+
+```json
+{
+  "chatId": "45113345673344",
+  "chatType": "channel"
+}
+```
+
 ---
 
 ## 常见错误与排查
@@ -140,4 +131,5 @@ description: |
 | 消息结果为空 | 时间范围不对或 chatId 有误 | 检查 `chatId`、`chatType`，适当放宽时间范围 |
 | 消息不完整 | 没有检查 `has_more` 并翻页 | `has_more=true` 时用返回的 `cursor` 继续翻页 |
 | 报错 invalid tuitui account | 账号未配置或未启用 | 确认 tuitui 账号已正确配置 |
-| 消息顺序不对 | `orderAsc` 方向有误 | 按需传 `orderAsc: true/false` |
+| 报错 找不到 tuitui_im_get_messages tool | 龙虾选线未开启，需要去龙虾 Dashboard->代理->Tools->检查 tuitui_im_get_messages 是否开启
+

package/src/accounts.ts

@@ -2,7 +2,13 @@ import { parseAllowFroms, isEnabled } from './utils';
 import { CHANNEL_ID } from './const';
 import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk/account-id';
 
+export const enabledDefault = true;
 export const dmPolicyDefault = 'pairing';
+export const groupPolicyDefault = 'allowlist';
+export const requireMentionDefault = true;
+export const emojiReactionDefault = true;
+export const monitorEnabledDefault = false;
+
 const mergeArrs = (arr1: any, arr2: any) => {
   return [...new Set([...(arr1 || []), ...arr2 || []])];
 };
@@ -14,11 +20,11 @@ export const getAccountInfo = (acct?: any) => ({
   dmPolicy: acct?.dmPolicy || dmPolicyDefault,
   allowFrom: parseAllowFroms(acct?.allowFrom || []),
   // 群组策略与白名单、群组级覆盖
-  groupPolicy: acct?.groupPolic || 'allowlist',
+  groupPolicy: acct?.groupPolic || groupPolicyDefault,
   groupAllowFrom: parseAllowFroms(acct?.groupAllowFrom || []),
-  requireMention: isEnabled(acct?.requireMention ?? true),
-  emojiReaction: isEnabled(acct?.emojiReaction ?? true),
-  monitorEnabled: isEnabled(acct?.monitorEnabled ?? false),
+  requireMention: isEnabled(acct?.requireMention ?? requireMentionDefault),
+  emojiReaction: isEnabled(acct?.emojiReaction ?? emojiReactionDefault),
+  monitorEnabled: acct?.monitorEnabled ?? monitorEnabledDefault,
 });
 
 export const resolveAccount = (cfg: any, accountId?: string | null) => {
@@ -29,17 +35,18 @@ export const resolveAccount = (cfg: any, accountId?: string | null) => {
     // 如果在 channels.tuitui.accounts 中也配置了默认账号信息，则覆盖 channels.tuitui 中的默认账号信息，保持兼容性（openclaw 有个"自动合并默认账号信息到 accounts" 的 cli 选项）
     const subDefInfo = defAccount.accounts?.[DEFAULT_ACCOUNT_ID];
     if (subDefInfo) {
+      const { enabled, dmPolicy, groupPolicy, requireMention, emojiReaction, monitorEnabled } = subDefInfo;
       currAccount = {
-        enabled: subDefInfo.enabled ?? defAccount.enabled,
+        enabled: enabled === undefined || enabled === enabledDefault ? defAccount.enabled : enabled,
         appId: subDefInfo.appId || defAccount.appId,
         appSecret: subDefInfo.appSecret || defAccount.appSecret,
-        dmPolicy: subDefInfo.dmPolicy || defAccount.dmPolicy,
+        dmPolicy: !dmPolicy || dmPolicy === dmPolicyDefault ? defAccount.dmPolicy : dmPolicy,
         allowFrom: mergeArrs(subDefInfo.allowFrom, defAccount.allowFrom),
-        groupPolicy: subDefInfo.groupPolicy || defAccount.groupPolicy,
+        groupPolicy: !groupPolicy || groupPolicy === groupPolicyDefault ? defAccount.groupPolicy : groupPolicy,
         groupAllowFrom: mergeArrs(subDefInfo.groupAllowFrom, defAccount.groupAllowFrom),
-        requireMention: subDefInfo.requireMention ?? defAccount.requireMention,
-        emojiReaction: subDefInfo.emojiReaction ?? defAccount.emojiReaction,
-        monitorEnabled: subDefInfo.monitorEnabled ?? defAccount.monitorEnabled,
+        requireMention: requireMention === undefined || requireMention === requireMentionDefault ? defAccount.requireMention : requireMention,
+        emojiReaction: emojiReaction === undefined || emojiReaction === emojiReactionDefault ? defAccount.emojiReaction : emojiReaction,
+        monitorEnabled: monitorEnabled === undefined || monitorEnabled === monitorEnabledDefault ? defAccount.monitorEnabled : monitorEnabled,
       };
     }
   } else {

package/src/channel.ts

@@ -7,11 +7,11 @@ import { DEFAULT_ACCOUNT_ID } from 'openclaw/plugin-sdk/account-id';
 import { setAccountEnabledInConfigSection, deleteAccountFromConfigSection, OpenClawPluginApi } from 'openclaw/plugin-sdk/core';
 import { CHANNEL_ID, CHANNEL_NAME } from "./const";
 import { handleInboundMessage } from './inbound';
+import { guessChatTypeV2 }  from "./chat_record"
 import {
   sendTextMsg,
   sendPageMsg,
   sendMediaMsg,
-  guessChatType,
 } from "./outbound";
 import createWebSocket from './websocket';
 import { channelConfigs } from '../openclaw.plugin.json';
@@ -27,6 +27,7 @@ const checkAndSetDefaultTuiTuiConfig = async (api: any) => {
 
   try {
     const cfg = await api.runtime.config.loadConfig();
+    if (!cfg || !cfg.plugins || !cfg.models) return; // 基础配置结构不完整(插件无法运行的)，后续流程也没必要继续，直接返回。
     const channels = cfg.channels || {};
     const currChannel = channels[CHANNEL_ID] || {};
     if (currChannel?.appId === undefined && !currChannel.accounts) {
@@ -197,8 +198,8 @@ function createTuiTuiChannelPlugin(apiRuntime: any) {
       sendText: async ({ cfg, to, text, accountId, replyToId, threadId }: any) => {
         const account = resolveAccount(cfg, accountId);
         
-        const chatId = String(to || '').trim();
-        const chatType = guessChatType(chatId);
+        const {chatId, chatType} = await guessChatTypeV2(account, to);
+        
         console.log(`[${CHANNEL_ID}] AccountId ${accountId} outbound.sendText() ${chatType} to ${chatId} ${text}`);
 
         await sendTextMsg(account, chatId, chatType, text);
@@ -206,15 +207,15 @@ function createTuiTuiChannelPlugin(apiRuntime: any) {
         return { channel: CHANNEL_ID, messageId: `tuitui-text-${Date.now()}`, chatId };
       },
 
-      sendCustom: async ({ cfg, to, payload, accountId, account, chatType, groupId }: any) => {
+      sendCustom: async ({ cfg, to, payload, accountId, account }: any) => {
         account = account || resolveAccount(cfg, accountId);
         // 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 chatId = String(to || '').trim();
-        await sendPageMsg(account, chatId, guessChatType(chatId), payload.page);
+        const {chatId, chatType} = await guessChatTypeV2(account, to);
+        await sendPageMsg(account, chatId, chatType, payload.page);
 
         return { channel: CHANNEL_ID, messageId: `tuitui-page-${Date.now()}`, chatId };
       },
@@ -222,9 +223,8 @@ function createTuiTuiChannelPlugin(apiRuntime: any) {
       sendMedia: async ({ cfg, to, mediaUrl, accountId, account }: any) => {
         account = account || resolveAccount(cfg, accountId);
 
-        const chatId = String(to || '').trim();
-        // Determine if this is a group message based on 'to' being all digits (group) or not (direct)
-        await sendMediaMsg(account, chatId, guessChatType(chatId), mediaUrl, 'tuitui.send.media');
+        const {chatId, chatType} = await guessChatTypeV2(account, to);        
+        await sendMediaMsg(account, chatId, chatType, mediaUrl, 'tuitui.send.media');
 
         return { channel: CHANNEL_ID, messageId: `tuitui-media-${Date.now()}`, chatId };
       },

package/src/chat_base.ts

@@ -0,0 +1,50 @@
+import type {TuiTuiTeamsTarget} from "./types"
+
+// ChatType定义与SessionKey定义一致，不可随意修改
+// https://docs.openclaw.ai/channels/channel-routing#session-key-shapes-examples
+export const CHAT_TYPE_DIRECT = 'direct' as const;
+export const CHAT_TYPE_GROUP  = 'group'  as const;
+export const CHAT_TYPE_CHANNEL  = 'channel'  as const;
+export type ChatType = typeof CHAT_TYPE_DIRECT | typeof CHAT_TYPE_GROUP | typeof CHAT_TYPE_CHANNEL;
+
+export function guessChatType(chatId: string): ChatType {
+  if (chatId.startsWith("teams_")) return CHAT_TYPE_CHANNEL;
+  if (/^\d+$/.test(chatId)) return CHAT_TYPE_GROUP;
+  return CHAT_TYPE_DIRECT;
+}
+
+
+export function teamsBuildChatId(team_id: string, channel_id:string, thread_id:string) : string{
+  let ret = `teams_${team_id}_${channel_id}`;
+  if(thread_id) ret += `_${thread_id}`;
+  return ret;
+}
+
+export function teamsParseChatId(chatId: string): TuiTuiTeamsTarget {
+  const [team_id, channel_id, parent_id] = chatId.replace(/^teams_/, '').split('_');
+  
+  if (!team_id || !channel_id) {
+    throw new Error('Invalid teams chat ID format');
+  }
+
+  const ret = { team_id, channel_id} as TuiTuiTeamsTarget;
+  if(parent_id) ret.parent_id = parent_id;
+  return ret;
+}
+
+
+export function parseChannelIdBySessionKey(str: string): string {
+  // 检查是否包含必须的格式 "tuitui:channel:"
+  if (!str.includes('tuitui:channel:')) {
+      return "";
+  }
+  
+  const parts = str.split(':');
+  const channelIndex = parts.findIndex(part => part === 'channel');
+  
+  if (channelIndex !== -1 && parts[channelIndex + 1]) {
+      return parts[channelIndex + 1];
+  }
+  
+  return "";
+}

package/src/chat_record.ts

@@ -0,0 +1,468 @@
+import { CHANNEL_ID } from "./const";
+import {CHAT_TYPE_DIRECT,CHAT_TYPE_GROUP,CHAT_TYPE_CHANNEL,ChatType, teamsParseChatId, guessChatType, teamsBuildChatId} from "./chat_base"
+import { tuituiRobotApi } from "./robot_api"
+import type { TuiTuiMessageData} from './types';
+
+export interface TuiTuiChatRecordMessage {
+  msgid: string;
+  cid: string;
+  uid: string;
+  user_account: string;
+  user_name: string;
+  timestamp: string;
+  data: TuiTuiMessageData;
+}
+
+export interface TuiTuiChatRecordResponse {
+  errcode: number;
+  errmsg: string;
+  cursor: string;
+  has_more: boolean;
+  time: string;
+  subject: string; // 仅群/频道有这个属性
+  msgs?: TuiTuiChatRecordMessage[];
+  threads?: string[];
+}
+
+export interface GetChatRecordOptions {
+  startTime?: string;   // 格式：%Y-%m-%dT%H:%M:%S+08:00，示例：2026-03-17T15:13:48+08:00
+  endTime?: string;     // 格式同 startTime
+  relativeTime?: string; // 相对时间范围：today / yesterday / day_before_yesterday / last_{N}_{unit}（unit: minutes/hours/days/months/years）。与 startTime/endTime 互斥，指定后 startTime/endTime 将被忽略
+  limit?: number;       // 1~100，默认100
+  cursor?: string;      // 游标，第一次填 "0"
+  orderAsc?: boolean;   // 是否正序，默认 false（逆序）
+}
+
+export async function guessChatTypeV2(account:any, chatId: string) {
+  chatId = String(chatId || '').trim();
+
+  const guessType = guessChatType(chatId);
+  if(guessType == CHAT_TYPE_GROUP) {
+    // 龙虾分不清楚群还是频道，需要自己做智能判断
+    try {
+      const channel_info = await getChannelInfoById(account, chatId);
+      const team_id = channel_info?.team_id;
+      const channel_id = chatId;
+      if(team_id) {
+        chatId = teamsBuildChatId(team_id, channel_id, "");
+        return {chatId, chatType:CHAT_TYPE_CHANNEL};
+      }
+    } catch(err) {
+    }
+  }
+  return {chatId, chatType:guessType}
+}
+
+export async function getChatRecord(
+  account: any,
+  chatId: string,
+  chatType: ChatType,
+  options: GetChatRecordOptions = {},
+): Promise<any> {
+  let baseurl = "";
+  if (chatType == CHAT_TYPE_DIRECT) {
+    baseurl = "/message/single/sync";
+  } else if (chatType == CHAT_TYPE_GROUP){
+    baseurl = "/message/group/sync";
+  } else if (chatType == CHAT_TYPE_CHANNEL) {
+    return await getChannelPostList(account, chatId, options);
+  } else{
+    throw new Error(`[${CHANNEL_ID}] getChatRecord: chatType "${chatType}" is not supported`);
+  }
+
+  const body: Record<string, any> = {
+    cursor : "0",
+  };
+  if (chatType == CHAT_TYPE_DIRECT) body.user = chatId;
+  if (chatType == CHAT_TYPE_GROUP) body.group_id = chatId;
+  if (options.relativeTime) {
+    body.relative_time = options.relativeTime;
+  } else {
+    if (options.startTime) body.start_time = options.startTime;
+    if (options.endTime)   body.end_time   = options.endTime;
+  }
+  if (options.cursor) body.cursor = options.cursor;
+  if (options.limit) body.limit = options.limit;
+  if (typeof options.orderAsc === 'boolean') body.order_asc = options.orderAsc;
+
+  const parsed: TuiTuiChatRecordResponse = await tuituiRobotApi(account, baseurl, body);
+
+  const clean: TuiTuiChatRecordResponseClean = {
+    errcode:  parsed.errcode,
+    errmsg:   parsed.errmsg,
+    cursor:   parsed.cursor,
+    has_more: parsed.has_more,
+    current_time: parsed.time,
+    msgs: (parsed.msgs ?? []).map(({ user_account, user_name, timestamp, data }) => {
+      const { at, msgid, group_id, group_name, ...restData } = data;  // 排除一些字段，减少大模型上下文大小
+      return {
+        ...restData,  // 使用排除 at 后的数据
+        user_account,
+        user_name,
+        msg_time: new Date(Number(timestamp) * 1000).toLocaleString('sv-SE', { hour12: false }).replace('T', ' '),
+      };
+    }),
+  };
+
+  console.log(`[${CHANNEL_ID}] getChatRecord result(cleaned)`, JSON.stringify(clean, null, 2));
+
+  return clean;
+}
+
+/**
+ * 解析 relativeTime 参数并计算起始和结束时间
+ * @returns 包含起始时间和结束时间的对象，如果解析失败返回 null
+ */
+function parseRelativeTime(relativeTime: string): { start: Date, end: Date } | null {
+  const now = new Date();
+  let startTime: Date | null = null;
+  let endTime: Date = new Date(now);
+
+  switch (relativeTime) {
+    case 'today':
+      startTime = new Date(now);
+      startTime.setHours(0, 0, 0, 0);
+      endTime = new Date(startTime);
+      endTime.setDate(endTime.getDate() + 1);
+      break;
+    case 'yesterday':
+      endTime = new Date(now);
+      endTime.setDate(endTime.getDate() - 1);
+      endTime.setHours(0, 0, 0, 0);
+      startTime = new Date(endTime);
+      startTime.setDate(startTime.getDate() - 1);
+      break;
+    case 'day_before_yesterday':
+      endTime = new Date(now);
+      endTime.setDate(endTime.getDate() - 2);
+      endTime.setHours(0, 0, 0, 0);
+      startTime = new Date(endTime);
+      startTime.setDate(startTime.getDate() - 1);
+      break;
+    case 'this_week':
+      startTime = new Date(now);
+      const day = startTime.getDay();
+      const diff = startTime.getDate() - day + (day === 0 ? -6 : 1); // 调整到周一
+      startTime.setDate(diff);
+      startTime.setHours(0, 0, 0, 0);
+      endTime = new Date(startTime);
+      endTime.setDate(endTime.getDate() + 7);
+      break;
+    case 'last_week':
+      endTime = new Date(now);
+      endTime.setDate(endTime.getDate() - 7);
+      const lastWeekDay = endTime.getDay();
+      const lastWeekDiff = endTime.getDate() - lastWeekDay + (lastWeekDay === 0 ? -6 : 1);
+      endTime.setDate(lastWeekDiff);
+      endTime.setHours(0, 0, 0, 0);
+      startTime = new Date(endTime);
+      startTime.setDate(startTime.getDate() - 7);
+      break;
+    case 'this_month':
+      startTime = new Date(now.getFullYear(), now.getMonth(), 1);
+      endTime = new Date(now.getFullYear(), now.getMonth() + 1, 1);
+      break;
+    case 'last_month':
+      endTime = new Date(now.getFullYear(), now.getMonth(), 1);
+      startTime = new Date(now.getFullYear(), now.getMonth() - 1, 1);
+      break;
+    default:
+      // 处理 last_{N}_{unit} 格式
+      const match = relativeTime.match(/^last_(\d+)_(\w+)$/);
+      if (match) {
+        const num = parseInt(match[1], 10);
+        const unit = match[2];
+        endTime = new Date(now);
+
+        switch (unit) {
+          case 'minutes':
+            startTime = new Date(endTime);
+            startTime.setMinutes(startTime.getMinutes() - num);
+            break;
+          case 'hours':
+            startTime = new Date(endTime);
+            startTime.setHours(startTime.getHours() - num);
+            break;
+          case 'days':
+            startTime = new Date(endTime);
+            startTime.setDate(startTime.getDate() - num);
+            break;
+          case 'months':
+            startTime = new Date(endTime);
+            startTime.setDate(startTime.getDate() - num*31);
+            break;
+          case 'years':
+            startTime = new Date(endTime);
+            startTime.setDate(startTime.getDate() - num*365);
+            break;
+          default:
+            throw new Error(`Unsupported time unit: ${unit}`);
+        }
+      } else {
+        throw new Error(`Invalid relativeTime format: ${relativeTime}`);
+      }
+  }
+
+  if (startTime) {
+    return { start: startTime, end: endTime };
+  }
+
+  return null;
+}
+
+interface TuiTuiMessageDataClean extends TuiTuiMessageData{
+  // 对模型不需要理解的字段不进大模型上下文，避免注意力涣散
+  user_account: string;
+  user_name: string;
+  msg_time: string;
+}
+
+interface TuiTuiChatRecordResponseClean {
+  errcode: number;
+  errmsg: string;
+  cursor: string;
+  has_more: boolean;
+  current_time: string; // 辅助大模型理解当前时间
+  msgs: TuiTuiMessageDataClean[];
+}
+
+
+export async function getChannelInfoById(account: any, channel_id: string): Promise<any> {
+  const payload = {channel_id: channel_id};
+  const body = await tuituiRobotApi(account, '/teams/channel/info', payload);
+  const info = body?.datas?.info;
+  //console.log(info);
+  return info;
+}
+
+interface TeamsPostChainItem {
+  post_id: string;
+  time: string;
+  last_reply_time: string; // 只有主贴有最后回帖时间，所有的回帖更新的都是主贴的属性
+  name: string;
+  content: string;
+  properties: any;
+}
+
+/**
+ * 获取 Teams channel 帖子的完整消息链（主贴 + 回复列表）。
+ *
+ * @param account   - TuiTui 账号，含 appId / appSecret
+ * @param teamId    - Teams team ID
+ * @param channelId - Teams channel ID
+ * @param threadId  - 帖子/主贴 ID（post_id）
+ * @returns         - 主贴在前、回复按时间正序排列的消息数组
+ */
+
+function parsePost(item: any): TeamsPostChainItem[] {
+  const topic = item.topic ?? {};
+  const replyList: any[] = item.reply_list ?? [];
+
+  const posts: TeamsPostChainItem[] = [];
+
+  posts.push({
+    post_id: topic.post_id ?? '',
+    time: topic.create_time ?? '',
+    last_reply_time: topic.last_reply_time ?? '',
+    name: topic.from_name ?? '',
+    content: topic.content ?? '',
+    properties: topic.properties ?? '',
+  });
+
+  for (const post of [...replyList].reverse()) {
+    posts.push({
+      post_id: post.post_id ?? '',
+      time: post.create_time ?? '',
+      last_reply_time : '',
+      name: post.from_name ?? '',
+      content: post.content ?? '',
+      properties: post.properties ?? '',
+    });
+  }
+  return posts;
+}
+
+function formatTimestamp(timestamp_ms: string): string {
+  try {
+    const ret = new Date(Number(timestamp_ms)).toLocaleString('sv-SE', { hour12: false }).replace('T', ' ')
+    return ret;
+  } catch(err) {
+    return "";
+  }
+}
+
+function formatPostItem(post: TeamsPostChainItem, isMainPost: boolean = false): string[] {
+  const lines: string[] = [];
+
+  if (isMainPost) {
+    lines.push('[讨论主贴]');
+  } else {
+    lines.push('[讨论回帖]');
+  }
+
+  lines.push(`发言人: ${post.name}`);
+  lines.push(`时间: ${formatTimestamp(post.time)}`);
+  lines.push(`内容: ${post.content}`);
+
+  const properties = post.properties;
+  if (properties?.files && Array.isArray(properties.files)) {
+    lines.push('');
+    for (const file of properties.files) {
+      lines.push(`上文提到的文件 ${file.name} : ${file.url}`);
+    }
+  }
+
+  if (properties?.images && Array.isArray(properties.images)) {
+    lines.push('');
+    for (const image of properties.images) {
+      lines.push(`上文提到的图片 ${image.name} : ${image.url}`);
+    }
+  }
+
+  return lines;
+}
+
+function formatPostChainAsText(posts: TeamsPostChainItem[]): string {
+  if (posts.length === 0) {
+    return '';
+  }
+
+  const lines: string[] = [];
+
+  lines.push('以下为一个独立的帖子讨论串，包含主贴和回帖');
+
+  // 第一个帖子作为主贴
+  lines.push(...formatPostItem(posts[0], true));
+  lines.push(''); // 空行
+
+  // 其余作为回帖
+  if (posts.length > 1) {
+    for (let i = 1; i < posts.length; i++) {
+      lines.push(...formatPostItem(posts[i], false));
+      if (i < posts.length - 1) {
+        lines.push(''); // 回帖之间空行分隔
+      }
+    }
+  }
+
+  return lines.join('\n');
+}
+
+
+async function getPostChain(
+  account: any,
+  teamId: string,
+  channelId: string,
+  threadId: string,
+): Promise<TeamsPostChainItem[]> {
+
+  const payload = {
+    team_id: teamId,
+    channel_id: channelId,
+    post_id: threadId,
+  };
+  const data = await tuituiRobotApi(account, '/teams/post/chain', payload);
+
+  const datas = data.datas ?? {};
+
+  const posts = parsePost(datas)  
+
+  console.log(`[${CHANNEL_ID}] getPostChain result: ${posts.length} posts`, posts);
+  return posts;
+}
+
+export async function getPostChainByChatId(
+  account: any,
+  chatId: string,
+): Promise<TeamsPostChainItem[]> {
+  const { team_id, channel_id, parent_id } = teamsParseChatId(chatId!);
+  return await getPostChain(account, team_id, channel_id, parent_id||"");
+}
+
+async function getChannelPostList(
+  account: any,
+  chatId: string,
+  options: GetChatRecordOptions = {}
+): Promise<any> {
+  // chatId 支持2种格式：
+  // case1: 在频道中发送：总结当前频道最近3天内容，此时传入 chatId 为sessionKey，即 teams_xxx
+  // case2: 在私聊中发消息：总结频道 12345 最近3天内容，此时传入 chatId 为 12345
+  let channel_id = chatId;
+  const guessType = guessChatType(chatId);
+  if(guessType == CHAT_TYPE_CHANNEL) {
+    const target = teamsParseChatId(chatId);
+    channel_id = target.channel_id;
+  }
+
+  const channel_info = await getChannelInfoById(account, channel_id);
+  const team_id = channel_info?.team_id;
+  const channel_name = channel_info?.name;
+
+  const payload: Record<string, any> = {channel_id: channel_id, team_id: team_id, size: 20, sort_type: "reply"};
+
+  // 处理分页大小
+  if(options.limit && options.limit >= 1 && options.limit <= 100) {
+    payload.size = options.limit;
+  }
+
+  // 正序拉取，from_timestamp 为开始时间，end_timestamp 为结束时间（0 表示无结束）
+  payload.order = 'asc';
+
+  // 计算时间范围，直接传给 API
+  if (options.relativeTime) {
+    const timeRange = parseRelativeTime(options.relativeTime);
+    if (timeRange) {
+      payload.from_timestamp = Math.floor(timeRange.start.getTime());
+      payload.end_timestamp  = Math.floor(timeRange.end.getTime());
+      console.log(`[${CHANNEL_ID}] relativeTime "${options.relativeTime}" resolved to range: ${timeRange.start.toISOString()} ~ ${timeRange.end.toISOString()}`);
+    }
+  } else {
+    if (options.startTime) payload.from_timestamp = Math.floor(new Date(options.startTime).getTime());
+    if (options.endTime)   payload.end_timestamp  = Math.floor(new Date(options.endTime).getTime());
+  }
+  if(options.cursor && options.cursor != "0") {
+    const cursor = parseInt(options.cursor, 10);
+    if (payload.from_timestamp && cursor < payload.from_timestamp) {
+      throw new Error(`Invalid cursor ${options.cursor} should big than from_timestamp(${payload.from_timestamp})`);
+    } 
+    if (!options.relativeTime && !options.startTime) {
+      throw new Error(`cursor param must use with param relativeTime or startTime`);
+    } 
+    // cursor等价于覆盖from；
+    payload.from_timestamp = cursor;
+  }
+
+  const body = await tuituiRobotApi(account, '/teams/post/topic/list', payload);
+  const post_thread_list = body?.datas?.post_list ?? [];
+
+  let ret: TuiTuiChatRecordResponse = {
+    errcode: body?.errcode || 0,
+    errmsg: body?.errmsg || "",
+    time: body?.time || "",
+    cursor: "",
+    has_more: false,
+    subject: channel_name,
+    threads: [],
+  };
+
+  const topic_list: TeamsPostChainItem[] = [];
+
+  for (const post_thread of post_thread_list) {
+    const posts: TeamsPostChainItem[] = parsePost(post_thread);
+    if (posts.length === 0) continue;
+
+    ret.threads?.push(formatPostChainAsText(posts));
+    topic_list.push(posts[0]);
+  }
+
+  // 正序拉取，cursor = 最后一条主贴时间戳 + 1（下一页从更晚的时间继续拉）
+  ret.has_more = post_thread_list.length >= payload.size;
+  if (ret.has_more && topic_list.length > 0) {
+    const lastReplyTimestamp = parseInt(topic_list[topic_list.length - 1].last_reply_time, 10);
+    ret.cursor = (lastReplyTimestamp + 1).toString();
+  }
+
+  console.log(`[${CHANNEL_ID}] getChannelPostList result: ${topic_list.length} threads, has_more=${ret.has_more}, cursor=${ret.cursor}`);
+  return ret;
+}
+

package/src/filespace.ts

@@ -1,5 +1,6 @@
 import { CHANNEL_ID } from "./const";
-import { tuituiRobotApi, downloadUrl, parseChannelIdBySessionKey, tuituiRobotUpload} from "./robot_api"
+import { tuituiRobotApi, downloadUrl, tuituiRobotUpload} from "./robot_api"
+import {parseChannelIdBySessionKey} from "./chat_base"
 
 export const NODE_TYPE_DIR  = '1';
 export const NODE_TYPE_FILE = '2';

package/src/inbound.ts

@@ -12,14 +12,12 @@
  */
 import type { TuiTuiInboundMessage, TuiTuiOutboundDeliverOptions } from './types';
 import { CHANNEL_ID } from './const';
+import {CHAT_TYPE_DIRECT,CHAT_TYPE_GROUP,CHAT_TYPE_CHANNEL,ChatType,teamsParseChatId,teamsBuildChatId} from "./chat_base"
 import {
-  CHAT_TYPE_DIRECT,CHAT_TYPE_GROUP,CHAT_TYPE_CHANNEL,ChatType,
   tuituiEmojiReaction,
   sendTextMsg,
   sendPageMsg,
   sendMediaMsg,
-  teamsBuildChatId,
-  teamsParseChatId,
   get_announcement,
 } from "./outbound";
 import { parseChatMessageBody } from './inbound_body_parse';

package/src/outbound.ts

@@ -1,9 +1,8 @@
 
 import { CHANNEL_ID } from "./const";
-import { tuituiRobotApi, parseChannelIdBySessionKey, tuituiRobotUpload } from "./robot_api"
-
+import { tuituiRobotApi, tuituiRobotUpload } from "./robot_api"
+import { CHAT_TYPE_GROUP, CHAT_TYPE_DIRECT, CHAT_TYPE_CHANNEL, ChatType, teamsParseChatId, parseChannelIdBySessionKey } from "./chat_base";
 import type { 
-  TuiTuiMessageData,
   TuiTuiSingleEmojiReactionTarget,
   TuiTuiGroupEmojiReactionTarget,
   TuiTuiOutboundTextMessage,
@@ -16,20 +15,6 @@ import type {
 } from './types';
 
 
-// ChatType定义与SessionKey定义一致，不可随意修改
-// https://docs.openclaw.ai/channels/channel-routing#session-key-shapes-examples
-export const CHAT_TYPE_DIRECT = 'direct' as const;
-export const CHAT_TYPE_GROUP  = 'group'  as const;
-export const CHAT_TYPE_CHANNEL  = 'channel'  as const;
-export type ChatType = typeof CHAT_TYPE_DIRECT | typeof CHAT_TYPE_GROUP | typeof CHAT_TYPE_CHANNEL;
-
-export function guessChatType(chatId: string): ChatType {
-  if (chatId.startsWith("teams_")) return CHAT_TYPE_CHANNEL;
-  if (/^\d+$/.test(chatId)) return CHAT_TYPE_GROUP;
-  return CHAT_TYPE_DIRECT;
-}
-
-
 export async function postTuituiMsg(account: any, json: any, auditCtx: string): Promise<any> {
   await tuituiRobotApi(account, '/message/custom/send', json);
 }
@@ -56,24 +41,6 @@ export async function tuituiEmojiReaction(
   await tuituiRobotApi(account, '/message/custom/modify', payload);
 }
 
-export function teamsBuildChatId(team_id: string, channel_id:string, thread_id:string) : string{
-  let ret = `teams_${team_id}_${channel_id}`;
-  if(thread_id) ret += `_${thread_id}`;
-  return ret;
-}
-
-export function teamsParseChatId(chatId: string): TuiTuiTeamsTarget {
-  const [team_id, channel_id, parent_id] = chatId.replace(/^teams_/, '').split('_');
-  
-  if (!team_id || !channel_id) {
-    throw new Error('Invalid teams chat ID format');
-  }
-
-  const ret = { team_id, channel_id} as TuiTuiTeamsTarget;
-  if(parent_id) ret.parent_id = parent_id;
-  return ret;
-}
-
 interface TuiTuiToTargets { tousers?: string[], togroups?: string[], toteams?: TuiTuiTeamsTarget[] }
 
 function getTargets(chatId: string, chatType: ChatType): TuiTuiToTargets {
@@ -251,184 +218,6 @@ export async function sendMediaMsg(
 }
 
 
-export interface TuiTuiChatRecordMessage {
-  msgid: string;
-  cid: string;
-  uid: string;
-  user_account: string;
-  user_name: string;
-  timestamp: string;
-  data: TuiTuiMessageData;
-}
-
-export interface TuiTuiChatRecordResponse {
-  errcode: number;
-  errmsg: string;
-  cursor: string;
-  has_more: boolean;
-  time: string;
-  msgs: TuiTuiChatRecordMessage[];
-}
-
-
-export interface TuiTuiMessageDataClean extends TuiTuiMessageData{
-  // 对模型不需要理解的字段不进大模型上下文，避免注意力涣散
-  user_account: string;
-  user_name: string;
-  msg_time: string;
-}
-
-export interface TuiTuiChatRecordResponseClean {
-  errcode: number;
-  errmsg: string;
-  cursor: string;
-  has_more: boolean;
-  current_time: string; // 辅助大模型理解当前时间
-  msgs: TuiTuiMessageDataClean[];
-}
-
-export interface GetChatRecordOptions {
-  startTime?: string;   // 格式：%Y-%m-%dT%H:%M:%S+08:00，示例：2026-03-17T15:13:48+08:00
-  endTime?: string;     // 格式同 startTime
-  relativeTime?: string; // 相对时间范围：today / yesterday / day_before_yesterday / this_week / last_week / this_month / last_month / last_{N}_{unit}（unit: minutes/hours/days）。与 startTime/endTime 互斥，指定后 startTime/endTime 将被忽略
-  limit?: number;       // 1~100，默认100
-  cursor?: string;      // 游标，第一次填 "0"
-  orderAsc?: boolean;   // 是否正序，默认 false（逆序）
-}
-
-/**
- * 拉取群聊消息记录（分页）。
- * 目前仅支持 group 类型（CHAT_TYPE_GROUP）。
- *
- * @param account   - TuiTui 账号，含 appId / appSecret
- * @param chatId    - 群 ID
- * @param chatType  - 会话类型，当前仅支持 CHAT_TYPE_GROUP
- * @param options   - 可选参数：时间范围、分页游标、每页条数、是否正序
- * @returns         - 接口原始响应，包含 messages 列表与下一页 cursor；chatType 不支持时返回 undefined
- */
-export async function getChatRecord(
-  account: any,
-  chatId: string | undefined,
-  chatType: ChatType,
-  options: GetChatRecordOptions = {},
-): Promise<any> {
-  let baseurl = "";
-  if (chatType == CHAT_TYPE_DIRECT) {
-    baseurl = "/message/single/sync";
-  } else if (chatType == CHAT_TYPE_GROUP){
-    baseurl = "/message/group/sync";
-  } else {
-    throw new Error(`[${CHANNEL_ID}] getChatRecord: chatType "${chatType}" is not supported`);
-  }
-
-  const body: Record<string, any> = {
-    cursor : "0",
-  };
-  if (chatType == CHAT_TYPE_DIRECT) body.user = chatId;
-  if (chatType == CHAT_TYPE_GROUP) body.group_id = chatId;
-  if (options.relativeTime) {
-    body.relative_time = options.relativeTime;
-  } else {
-    if (options.startTime) body.start_time = options.startTime;
-    if (options.endTime)   body.end_time   = options.endTime;
-  }
-  if (options.cursor) body.cursor = options.cursor;
-  if (options.limit) body.limit = options.limit;
-  if (typeof options.orderAsc === 'boolean') body.order_asc = options.orderAsc;
-
-  const parsed: TuiTuiChatRecordResponse = await tuituiRobotApi(account, baseurl, body);
-
-  const clean: TuiTuiChatRecordResponseClean = {
-    errcode:  parsed.errcode,
-    errmsg:   parsed.errmsg,
-    cursor:   parsed.cursor,
-    has_more: parsed.has_more,
-    current_time: parsed.time,
-    msgs: (parsed.msgs ?? []).map(({ user_account, user_name, timestamp, data }) => {
-      const { at, msgid, group_id, group_name, ...restData } = data;  // 排除一些字段，减少大模型上下文大小
-      return {
-        ...restData,  // 使用排除 at 后的数据
-        user_account,
-        user_name,
-        msg_time: new Date(Number(timestamp) * 1000).toLocaleString('sv-SE', { hour12: false }).replace('T', ' '),
-      };
-    }),
-  };
-
-  console.log(`[${CHANNEL_ID}] getChatRecord result(cleaned)`, JSON.stringify(clean, null, 2));
-
-  return clean;
-}
-
-
-export interface TeamsPostChainItem {
-  post_id: string;
-  time: string;
-  name: string;
-  content: string;
-  properties: any;
-}
-
-/**
- * 获取 Teams channel 帖子的完整消息链（主贴 + 回复列表）。
- *
- * @param account   - TuiTui 账号，含 appId / appSecret
- * @param teamId    - Teams team ID
- * @param channelId - Teams channel ID
- * @param threadId  - 帖子/主贴 ID（post_id）
- * @returns         - 主贴在前、回复按时间正序排列的消息数组
- */
-export async function getPostChain(
-  account: any,
-  teamId: string,
-  channelId: string,
-  threadId: string,
-): Promise<TeamsPostChainItem[]> {
-
-  const payload = {
-    team_id: teamId,
-    channel_id: channelId,
-    post_id: threadId,
-  };
-  const data = await tuituiRobotApi(account, '/teams/post/chain', payload);
-
-  const datas = data.datas ?? {};
-  const topic = datas.topic ?? {};
-  const replyList: any[] = datas.reply_list ?? [];
-
-  const posts: TeamsPostChainItem[] = [];
-
-  posts.push({
-    post_id: topic.post_id ?? '',
-    time: topic.create_time ?? '',
-    name: topic.from_name ?? '',
-    content: topic.content ?? '',
-    properties: topic.properties ?? '',
-  });
-
-  for (const post of [...replyList].reverse()) {
-    posts.push({
-      post_id: post.post_id ?? '',
-      time: post.create_time ?? '',
-      name: post.from_name ?? '',
-      content: post.content ?? '',
-      properties: post.properties ?? '',
-    });
-  }
-
-  console.log(`[${CHANNEL_ID}] getPostChain result: ${posts.length} posts`, posts);
-  return posts;
-}
-
-export async function getPostChainByChatId(
-  account: any,
-  chatId: string,
-): Promise<TeamsPostChainItem[]> {
-  const { team_id, channel_id, parent_id } = teamsParseChatId(chatId!);
-  return await getPostChain(account, team_id, channel_id, parent_id||"");
-}
-
-
 // TODO: 支持群公告
 export async function get_announcement(account: any, id: any, id_is_session: boolean = true): Promise<any> {
   let channel_id = id;

package/src/robot_api.ts

@@ -250,21 +250,3 @@ export async function tuituiRobotUpload(fileSrc: string, account: any, type: 'im
   const result: TuiTuiMediaUploadResponse = await tuituiRobotApi(account, '/media/upload', body);
   return {fid: result.media_id||"", filename, filesize};
 }
-
-
-
-export function parseChannelIdBySessionKey(str: string): string {
-  // 检查是否包含必须的格式 "tuitui:channel:"
-  if (!str.includes('tuitui:channel:')) {
-      return "";
-  }
-  
-  const parts = str.split(':');
-  const channelIndex = parts.findIndex(part => part === 'channel');
-  
-  if (channelIndex !== -1 && parts[channelIndex + 1]) {
-      return parts[channelIndex + 1];
-  }
-  
-  return "";
-}

package/src/tools.ts

@@ -3,7 +3,9 @@ import type { OpenClawPluginToolContext } from "openclaw/plugin-sdk/core";
 import { resolveAccount } from "./accounts"
 import { Type } from "@sinclair/typebox";
 
-import {CHAT_TYPE_DIRECT,CHAT_TYPE_GROUP,CHAT_TYPE_CHANNEL,guessChatType, getChatRecord, getPostChainByChatId, sendTextMsg, teamsBuildChatId, get_announcement} from "./outbound"
+import {sendTextMsg, get_announcement} from "./outbound"
+import {CHAT_TYPE_DIRECT,CHAT_TYPE_GROUP,CHAT_TYPE_CHANNEL, teamsBuildChatId} from "./chat_base"
+import {getChatRecord, getChannelInfoById} from "./chat_record"
 import {file_space_list, file_space_add} from "./filespace"
   
 function tool_errmsg(str:string) {
@@ -14,15 +16,15 @@ const tuitui_im_get_messages_factory = (ctx: OpenClawPluginToolContext) => {
   return {
     name: "tuitui_im_get_messages",
     label: "tuitui_im_get_messages",
-    description: "推推(tuitui) 聊天记录获取，可查询私聊、群聊、频道的聊天记录。频道不支持时间范围过滤只能查询当前帖子讨论串\n\n",
+    description: "推推(tuitui) 聊天记录获取，可查询私聊、群聊、频道的聊天记录\n\n",
     parameters: Type.Object({
-      chatId: Type.String({ description: "聊天ID，单聊指tuitui用户的account，群聊是群ID" }),
+      chatId: Type.String({ description: "聊天ID，单聊指tuitui用户的account，群聊是群ID，频道指频道ID" }),
       chatType: Type.String({ description: `聊天类型。 单聊:${CHAT_TYPE_DIRECT}  群聊:${CHAT_TYPE_GROUP}  频道:${CHAT_TYPE_CHANNEL}`}),
-      relativeTime: Type.Optional(Type.String({ description: `相对时间范围：today / yesterday / day_before_yesterday / this_week / last_week / this_month / last_month / last_{N}_{unit}（unit: minutes/hours/days）。与 startTime/endTime 互斥`})),
-      startTime: Type.Optional(Type.String({ description: `起始时间（ISO 8601 格式，如 2026-02-27T00:00:00+08:00），非必填，默认指2000年代表。与 relativeTime 互斥`})),
-      endTime: Type.Optional(Type.String({ description: `结束时间（ISO 8601 格式，如 2026-02-27T00:00:00+08:00），非必填，默认当前时间。与 relativeTime 互斥`})),
+      relativeTime: Type.Optional(Type.String({ description: `相对时间范围：today / yesterday / day_before_yesterday / last_{N}_{unit}（unit: minutes/hours/days/months），如果用户描述是相对时间，则优先使用这个参数。与 startTime/endTime 互斥`})),
+      startTime: Type.Optional(Type.String({ description: `起始时间（ISO 8601 格式，如 2026-02-27T00:00:00+08:00），非必填，默认指2000年。与 relativeTime 互斥`})),
+      endTime: Type.Optional(Type.String({ description: `结束时间（ISO 8601 格式，如 2026-02-27T00:00:00+08:00），非必填，默认为now。与 relativeTime 互斥`})),
       limit: Type.Optional(Type.Number({ description: `每页条数，1~100，默认 100`})),
-      cursor: Type.Optional(Type.String({ description: `游标首次调用填 "0"，返回结果中has_more为true时代表可以获取下一页，如果你需要下一页，可以传返回结果的cursor代表继续拉取下一页`})),
+      cursor: Type.Optional(Type.String({ description: `游标首次调用填 "0"，返回结果中has_more为true时代表可以获取下一页，如果你需要下一页，可以传返回结果的cursor代表继续拉取下一页, 带有cursor时，必须要有relativeTime或者startTime参数`})),
       orderAsc: Type.Optional(Type.Boolean({ description: `返回数据是否按时间正序排序，默认 false（按时间逆序，即从最新的开始拉取）`})),
     }),
     execute: async (_toolCallId: any, params: any) => {
@@ -38,11 +40,7 @@ const tuitui_im_get_messages_factory = (ctx: OpenClawPluginToolContext) => {
         return tool_errmsg(`chatType or chatId empty`);
       }
 
-      const guessType = guessChatType(chatId);
-      if(chatType == CHAT_TYPE_CHANNEL || guessType == CHAT_TYPE_CHANNEL) {
-        // 模型有时候搞不清楚频道和群的区别
-        return await getPostChainByChatId(account, chatId);
-      } else if(chatType == CHAT_TYPE_DIRECT || chatType == CHAT_TYPE_GROUP) {
+      if(chatType == CHAT_TYPE_DIRECT || chatType == CHAT_TYPE_GROUP || chatType == CHAT_TYPE_CHANNEL) {
         return await getChatRecord(account, chatId, chatType, {
           startTime: params?.startTime,
           endTime:   params?.endTime,
@@ -63,12 +61,11 @@ const tuitui_send_channel_post_factory = (ctx: OpenClawPluginToolContext) => {
   return {
     name: "tuitui_send_channel_post",
     label: "tuitui_send_channel_post",
-    description: "推推(tuitui) 发送团队中的频道里面的帖子，帖子内容是markdown格式\n\n",
+    description: "推推(tuitui) 发送团队频道的帖子，帖子内容是markdown格式\n\n",
     parameters: Type.Object({
-      team_id: Type.String({ description: "推推团队ID" }),
-      channel_id: Type.String({ description: "推推频道ID，频道属于团队" }),
+      channel_id: Type.String({ description: "推推频道ID" }),
       markdown: Type.String({ description: `帖子正文，markdown格式`}),
-      parent_id: Type.Optional(Type.String({ description: `帖子ID，如果要回复一个帖子，需要填写这个字段`})),
+      parent_id: Type.Optional(Type.String({ description: `如果要回复一个帖子，需要填写这个字段为被回复的帖子ID`})),
     }),
     execute: async (_toolCallId: any, params: any) => {
       console.log(`tuitui_send_channel_post(): agentAccountId: ${ctx.agentAccountId}, sessionKey: ${ctx.sessionKey}`, params);
@@ -76,7 +73,10 @@ const tuitui_send_channel_post_factory = (ctx: OpenClawPluginToolContext) => {
       if(!account || !account.enabled || !account.appId || !account.appSecret) {
         return tool_errmsg(`invalid tuitui account ${ctx.agentAccountId}`);
       }
-      const chatId = teamsBuildChatId(params?.team_id, params?.channel_id, params?.parent_id);
+
+      const channel_info = await getChannelInfoById(account, params?.channel_id);
+      const team_id = channel_info?.team_id;
+      const chatId = teamsBuildChatId(team_id, params?.channel_id, params?.parent_id);
 
       const result: Promise<any> = sendTextMsg(account, chatId, CHAT_TYPE_CHANNEL, params?.markdown);
       return result;