@larksuite/openclaw-lark 2025.7.15-beta.0

package/src/messaging/outbound/actions.js

@@ -0,0 +1,329 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * ChannelMessageActionAdapter for the Lark/Feishu channel plugin.
+ *
+ * Implements the standard message-action interface so the framework's
+ * built-in `message` tool can route send, react, delete and other
+ * actions to Feishu.
+ *
+ * The `send` action is the unified entry-point for text, card, media,
+ * reply and attachment delivery — matching the Telegram/Discord pattern
+ * where a single action handles all outbound message types.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.feishuMessageActions = void 0;
+const tool_send_1 = require("openclaw/plugin-sdk/tool-send");
+const param_readers_1 = require("openclaw/plugin-sdk/param-readers");
+const typebox_1 = require("@sinclair/typebox");
+const sdk_compat_1 = require("../../core/sdk-compat.js");
+const lark_client_1 = require("../../core/lark-client.js");
+const accounts_1 = require("../../core/accounts.js");
+const lark_logger_1 = require("../../core/lark-logger.js");
+const reactions_1 = require("./reactions.js");
+const deliver_1 = require("./deliver.js");
+const media_1 = require("./media.js");
+const log = (0, lark_logger_1.larkLogger)('outbound/actions');
+const FEISHU_SEND_TEXT_DESCRIPTION = 'Text to send as a separate Feishu message. During a normal Feishu streaming-card reply, do not call send just to repeat or finalize the same answer; return the final answer normally so the active card can be completed by the reply dispatcher. Use send only when the user explicitly needs an additional separate message.';
+const FEISHU_MESSAGE_TOOL_SCHEMA = {
+    properties: {
+        message: typebox_1.Type.Optional(typebox_1.Type.String({ description: FEISHU_SEND_TEXT_DESCRIPTION })),
+        text: typebox_1.Type.Optional(typebox_1.Type.String({ description: FEISHU_SEND_TEXT_DESCRIPTION })),
+    },
+    visibility: 'current-channel',
+};
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Assert that a Lark SDK response has code === 0 (or no code field). */
+// eslint-disable-next-line @typescript-eslint/no-explicit-any
+function assertLarkOk(res, context) {
+    const code = res?.code;
+    if (code !== undefined && code !== 0) {
+        const msg = res?.msg ?? 'unknown error';
+        throw new Error(`[feishu-actions] ${context}: code=${code}, msg=${msg}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// Supported actions
+// ---------------------------------------------------------------------------
+const SUPPORTED_ACTIONS = new Set([
+    'send',
+    'react',
+    'reactions',
+    'delete',
+    'unsend',
+    // "member-info",
+]);
+// ---------------------------------------------------------------------------
+// Send param extraction
+// ---------------------------------------------------------------------------
+/** Try to resolve a card param to a plain object. Accepts objects directly or JSON strings. */
+function parseCardParam(raw) {
+    if (raw == null)
+        return undefined;
+    // Already a non-array object — use directly (empty {} is never a valid card).
+    if (typeof raw === 'object' && !Array.isArray(raw)) {
+        const obj = raw;
+        if (Object.keys(obj).length === 0)
+            return undefined;
+        return obj;
+    }
+    // String — attempt JSON.parse.
+    if (typeof raw === 'string') {
+        const trimmed = raw.trim();
+        if (!trimmed.startsWith('{') || !trimmed.endsWith('}')) {
+            log.warn('params.card is a string but not a JSON object, ignoring');
+            return undefined;
+        }
+        try {
+            const parsed = JSON.parse(trimmed);
+            if (typeof parsed === 'object' && parsed != null && !Array.isArray(parsed)) {
+                log.info('params.card was a JSON string, parsed successfully');
+                return parsed;
+            }
+            log.warn('params.card JSON parsed but is not a plain object, ignoring');
+            return undefined;
+        }
+        catch {
+            log.warn('params.card is a string but failed to JSON.parse, ignoring');
+            return undefined;
+        }
+    }
+    // Other types (number, boolean, etc.) — ignore with warning.
+    log.warn(`params.card has unexpected type "${typeof raw}", ignoring`);
+    return undefined;
+}
+/**
+ * Extract and normalise all send-related parameters from the raw action params.
+ * When `toolContext` is provided, thread context is inherited so that replies
+ * are routed to the correct thread.
+ */
+function readFeishuSendParams(params, toolContext) {
+    const to = (0, param_readers_1.readStringParam)(params, 'to') ?? '';
+    const text = (0, param_readers_1.readStringParam)(params, 'message', { allowEmpty: true }) ??
+        (0, param_readers_1.readStringParam)(params, 'text', { allowEmpty: true }) ??
+        '';
+    const mediaUrl = (0, param_readers_1.readStringParam)(params, 'media') ??
+        (0, param_readers_1.readStringParam)(params, 'path') ??
+        (0, param_readers_1.readStringParam)(params, 'filePath') ??
+        (0, param_readers_1.readStringParam)(params, 'url');
+    const fileName = (0, param_readers_1.readStringParam)(params, 'fileName') ?? (0, param_readers_1.readStringParam)(params, 'name');
+    // Thread routing: when targeting the current chat (or unspecified),
+    // inherit thread context from SDK toolContext.
+    const sameChat = !to || to === toolContext?.currentChannelId;
+    const replyInThread = sameChat && Boolean(toolContext?.currentThreadTs);
+    const replyToMessageId = (0, param_readers_1.readStringParam)(params, 'replyTo') ??
+        (replyInThread && toolContext?.currentMessageId ? String(toolContext.currentMessageId) : undefined);
+    const card = parseCardParam(params.card);
+    return {
+        to,
+        text,
+        mediaUrl: mediaUrl ?? undefined,
+        fileName: fileName ?? undefined,
+        replyToMessageId: replyToMessageId ?? undefined,
+        replyInThread,
+        card,
+    };
+}
+// ---------------------------------------------------------------------------
+// Adapter
+// ---------------------------------------------------------------------------
+exports.feishuMessageActions = {
+    describeMessageTool: ({ cfg }) => {
+        const accounts = (0, accounts_1.getEnabledLarkAccounts)(cfg);
+        if (accounts.length === 0) {
+            return { actions: [], capabilities: [], schema: null };
+        }
+        return {
+            actions: Array.from(SUPPORTED_ACTIONS),
+            capabilities: ['cards'],
+            schema: FEISHU_MESSAGE_TOOL_SCHEMA,
+        };
+    },
+    supportsAction: ({ action }) => SUPPORTED_ACTIONS.has(action),
+    extractToolSend: ({ args }) => (0, tool_send_1.extractToolSend)(args, 'sendMessage'),
+    handleAction: async (ctx) => {
+        const { action, params, cfg, accountId, toolContext } = ctx;
+        const aid = accountId ?? undefined;
+        log.info(`handleAction: action=${action}, accountId=${aid ?? 'default'}`);
+        try {
+            switch (action) {
+                case 'send':
+                    return await deliverMessage(cfg, readFeishuSendParams(params, toolContext), aid, ctx.mediaLocalRoots);
+                case 'react':
+                    return await handleReact(cfg, params, aid);
+                case 'reactions':
+                    return await handleReactions(cfg, params, aid);
+                case 'delete':
+                case 'unsend':
+                    return await handleDelete(cfg, params, aid);
+                default:
+                    throw new Error(`Action "${action}" is not supported for Feishu. ` +
+                        `Supported actions: ${Array.from(SUPPORTED_ACTIONS).join(', ')}.`);
+            }
+        }
+        catch (err) {
+            const errMsg = err instanceof Error ? err.message : String(err);
+            log.error(`handleAction failed: action=${action}, error=${errMsg}`);
+            throw err;
+        }
+    },
+};
+// ---------------------------------------------------------------------------
+// Unified message delivery
+// ---------------------------------------------------------------------------
+/**
+ * Unified message delivery — handles text, card, and media payloads with
+ * optional reply-to and thread routing.
+ *
+ * Supports `fileName` for named file uploads via `uploadAndSendMediaLark`.
+ * On media upload failure, falls back to sending the URL as a text link.
+ */
+async function deliverMessage(cfg, sp, accountId, mediaLocalRoots) {
+    const { to, text, mediaUrl, fileName, replyToMessageId, replyInThread, card } = sp;
+    const payloadType = card ? 'card' : mediaUrl ? 'media' : 'text';
+    const target = to || replyToMessageId || 'unknown';
+    log.info(`deliverMessage: type=${payloadType}, target=${target}, ` +
+        `isReply=${Boolean(replyToMessageId)}, replyInThread=${replyInThread}, ` +
+        `textLen=${text.trim().length}, hasMedia=${Boolean(mediaUrl)}, ` +
+        `fileName=${fileName ?? '(none)'}`);
+    if (!text.trim() && !card && !mediaUrl) {
+        log.warn('deliverMessage: no payload, rejecting');
+        throw new Error('send requires at least one of: message, card, or media.');
+    }
+    const sendCtx = { cfg, to, replyToMessageId, replyInThread, accountId };
+    // Send text first if both text and card/media are present.
+    if (text.trim() && (card || mediaUrl)) {
+        log.info(`deliverMessage: sending preceding text ` + `(${text.length} chars) before ${payloadType}`);
+        await (0, deliver_1.sendTextLark)({ ...sendCtx, text });
+    }
+    // Card path.
+    if (card) {
+        const result = await (0, deliver_1.sendCardLark)({ ...sendCtx, card });
+        log.info(`deliverMessage: card sent, messageId=${result.messageId}`);
+        return (0, sdk_compat_1.jsonResult)({ ok: true, messageId: result.messageId, chatId: result.chatId });
+    }
+    // Media path — uses uploadAndSendMediaLark directly to support fileName.
+    if (mediaUrl) {
+        return await deliverMedia(cfg, sp, accountId, mediaLocalRoots);
+    }
+    // Text-only path.
+    const result = await (0, deliver_1.sendTextLark)({ ...sendCtx, text });
+    log.info(`deliverMessage: text sent, messageId=${result.messageId}`);
+    return (0, sdk_compat_1.jsonResult)({ ok: true, messageId: result.messageId, chatId: result.chatId });
+}
+/**
+ * Upload and send a media file with text-link fallback on failure.
+ */
+async function deliverMedia(cfg, sp, accountId, mediaLocalRoots) {
+    const { to, mediaUrl, fileName, replyToMessageId, replyInThread } = sp;
+    log.info(`deliverMedia: url=${mediaUrl}, fileName=${fileName ?? '(auto)'}`);
+    try {
+        const result = await (0, media_1.uploadAndSendMediaLark)({
+            cfg,
+            to,
+            mediaUrl,
+            fileName,
+            replyToMessageId,
+            replyInThread,
+            accountId,
+            mediaLocalRoots,
+        });
+        log.info(`deliverMedia: sent, messageId=${result.messageId}`);
+        return (0, sdk_compat_1.jsonResult)({ ok: true, messageId: result.messageId, chatId: result.chatId });
+    }
+    catch (err) {
+        const errMsg = err instanceof Error ? err.message : String(err);
+        log.error(`deliverMedia: upload failed for "${mediaUrl}": ${errMsg}`);
+        // Fallback: send the URL with error reason as a quote above.
+        log.info('deliverMedia: falling back to text link');
+        const fallback = await (0, deliver_1.sendTextLark)({
+            cfg,
+            to,
+            text: `> ${mediaUrl}`,
+            replyToMessageId,
+            replyInThread,
+            accountId,
+        });
+        return (0, sdk_compat_1.jsonResult)({
+            ok: true,
+            messageId: fallback.messageId,
+            chatId: fallback.chatId,
+            warning: `Media upload failed (${errMsg}). A text link was sent instead.`,
+        });
+    }
+}
+// ---------------------------------------------------------------------------
+// Reaction handlers
+// ---------------------------------------------------------------------------
+async function handleReact(cfg, params, accountId) {
+    const messageId = (0, param_readers_1.readStringParam)(params, 'messageId', { required: true });
+    const { emoji, remove, isEmpty } = (0, sdk_compat_1.readReactionParams)(params, {
+        removeErrorMessage: 'Emoji is required to remove a Feishu reaction.',
+    });
+    if (remove || isEmpty) {
+        log.info(`react: removing emoji=${emoji || 'all'} from messageId=${messageId}`);
+        const reactions = await (0, reactions_1.listReactionsFeishu)({
+            cfg,
+            messageId,
+            emojiType: emoji || undefined,
+            accountId,
+        });
+        const botReactions = reactions.filter((r) => r.operatorType === 'app');
+        for (const r of botReactions) {
+            await (0, reactions_1.removeReactionFeishu)({
+                cfg,
+                messageId,
+                reactionId: r.reactionId,
+                accountId,
+            });
+        }
+        log.info(`react: removed ${botReactions.length} bot reaction(s)`);
+        return (0, sdk_compat_1.jsonResult)({ ok: true, removed: botReactions.length });
+    }
+    log.info(`react: adding emoji=${emoji} to messageId=${messageId}`);
+    const { reactionId } = await (0, reactions_1.addReactionFeishu)({
+        cfg,
+        messageId,
+        emojiType: emoji,
+        accountId,
+    });
+    log.info(`react: added reactionId=${reactionId}`);
+    return (0, sdk_compat_1.jsonResult)({ ok: true, reactionId });
+}
+async function handleReactions(cfg, params, accountId) {
+    const messageId = (0, param_readers_1.readStringParam)(params, 'messageId', { required: true });
+    const emojiType = (0, param_readers_1.readStringParam)(params, 'emoji');
+    const reactions = await (0, reactions_1.listReactionsFeishu)({
+        cfg,
+        messageId,
+        emojiType: emojiType || undefined,
+        accountId,
+    });
+    return (0, sdk_compat_1.jsonResult)({
+        ok: true,
+        reactions: reactions.map((r) => ({
+            reactionId: r.reactionId,
+            emoji: r.emojiType,
+            operatorType: r.operatorType,
+            operatorId: r.operatorId,
+        })),
+    });
+}
+// ---------------------------------------------------------------------------
+// Delete
+// ---------------------------------------------------------------------------
+async function handleDelete(cfg, params, accountId) {
+    const messageId = (0, param_readers_1.readStringParam)(params, 'messageId', { required: true });
+    log.info(`delete: messageId=${messageId}`);
+    const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+    const res = await client.im.message.delete({
+        path: { message_id: messageId },
+    });
+    assertLarkOk(res, `delete message ${messageId}`);
+    log.info(`delete: done, messageId=${messageId}`);
+    return (0, sdk_compat_1.jsonResult)({ ok: true, messageId, deleted: true });
+}

package/src/messaging/outbound/bot-peer-context.d.ts

@@ -0,0 +1,42 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * AsyncLocalStorage-backed channel for telling the outbound adapter that
+ * the current dispatch is replying to a bot peer in a group chat.
+ *
+ * Why ALS instead of an extra adapter parameter: the outbound adapter is
+ * channel-agnostic (Slack / Telegram / Feishu share the same shape) and
+ * the SDK owns the call site between dispatch and our outbound. Adding a
+ * Feishu-specific "peer-is-bot" parameter would pollute that interface.
+ * ALS lets the dispatch layer attach context once and have it flow through
+ * the SDK's async chain to the outbound adapter without any other layer
+ * needing to know.
+ *
+ * Lifetime: scoped to a single `runWithBotPeerContext(...)` call. When that
+ * promise settles, the store is gone. No manual cleanup required.
+ */
+export interface BotPeerContext {
+    /** The peer bot's open_id — what `ensureMention` will inject. */
+    peerOpenId: string;
+    /** Display name for the rendered `<at>` element. */
+    peerName: string;
+    /**
+     * Mutable de-dup flag: set once the peer @ has appeared on an outbound
+     * chunk (model-written or injected) so multi-chunk replies don't prepend
+     * the @ to every chunk. Scoped to the single dispatch via the store.
+     */
+    mentioned?: boolean;
+}
+/**
+ * Run `fn` with the given bot-peer context attached to the async chain.
+ * The outbound adapter's `currentBotPeerContext()` inside `fn` (and any
+ * promises it spawns) will see this store.
+ */
+export declare function runWithBotPeerContext<T>(ctx: BotPeerContext, fn: () => Promise<T>): Promise<T>;
+/**
+ * Read the active bot-peer context, or `undefined` if none is set.
+ * Outbound code uses this to decide whether to wrap the reply text with
+ * `ensureMention` so the peer bot actually receives a Feishu notification.
+ */
+export declare function currentBotPeerContext(): BotPeerContext | undefined;

package/src/messaging/outbound/bot-peer-context.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * AsyncLocalStorage-backed channel for telling the outbound adapter that
+ * the current dispatch is replying to a bot peer in a group chat.
+ *
+ * Why ALS instead of an extra adapter parameter: the outbound adapter is
+ * channel-agnostic (Slack / Telegram / Feishu share the same shape) and
+ * the SDK owns the call site between dispatch and our outbound. Adding a
+ * Feishu-specific "peer-is-bot" parameter would pollute that interface.
+ * ALS lets the dispatch layer attach context once and have it flow through
+ * the SDK's async chain to the outbound adapter without any other layer
+ * needing to know.
+ *
+ * Lifetime: scoped to a single `runWithBotPeerContext(...)` call. When that
+ * promise settles, the store is gone. No manual cleanup required.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runWithBotPeerContext = runWithBotPeerContext;
+exports.currentBotPeerContext = currentBotPeerContext;
+const node_async_hooks_1 = require("node:async_hooks");
+const storage = new node_async_hooks_1.AsyncLocalStorage();
+/**
+ * Run `fn` with the given bot-peer context attached to the async chain.
+ * The outbound adapter's `currentBotPeerContext()` inside `fn` (and any
+ * promises it spawns) will see this store.
+ */
+function runWithBotPeerContext(ctx, fn) {
+    return storage.run(ctx, fn);
+}
+/**
+ * Read the active bot-peer context, or `undefined` if none is set.
+ * Outbound code uses this to decide whether to wrap the reply text with
+ * `ensureMention` so the peer bot actually receives a Feishu notification.
+ */
+function currentBotPeerContext() {
+    return storage.getStore();
+}

package/src/messaging/outbound/chat-manage.d.ts

@@ -0,0 +1,64 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Chat management for the Lark/Feishu channel plugin.
+ *
+ * Provides functions to update chat settings (name, avatar), manage
+ * members (add, remove, list) using the IM Chat API.
+ */
+import type { OpenClawConfig } from 'openclaw/plugin-sdk';
+export interface FeishuChatMember {
+    /** Member ID (open_id by default). */
+    memberId: string;
+    /** Display name of the member. */
+    name: string;
+    /** ID type: "open_id", "union_id", or "user_id". */
+    memberIdType: string;
+}
+/**
+ * Update chat settings such as name or avatar.
+ */
+export declare function updateChatFeishu(params: {
+    cfg: OpenClawConfig;
+    chatId: string;
+    name?: string;
+    avatar?: string;
+    accountId?: string;
+}): Promise<void>;
+/**
+ * Add members to a chat by their open_id list.
+ */
+export declare function addChatMembersFeishu(params: {
+    cfg: OpenClawConfig;
+    chatId: string;
+    memberIds: string[];
+    accountId?: string;
+}): Promise<void>;
+/**
+ * Remove members from a chat by their open_id list.
+ */
+export declare function removeChatMembersFeishu(params: {
+    cfg: OpenClawConfig;
+    chatId: string;
+    memberIds: string[];
+    accountId?: string;
+}): Promise<void>;
+/**
+ * List members of a chat.
+ *
+ * Returns a single page (up to 100 members) to avoid unnecessary data
+ * overhead for large groups.  Use the returned `pageToken` to fetch
+ * subsequent pages when needed.
+ */
+export declare function listChatMembersFeishu(params: {
+    cfg: OpenClawConfig;
+    chatId: string;
+    accountId?: string;
+    /** Optional page token for pagination. */
+    pageToken?: string;
+}): Promise<{
+    members: FeishuChatMember[];
+    pageToken?: string;
+    hasMore: boolean;
+}>;

package/src/messaging/outbound/chat-manage.js

@@ -0,0 +1,117 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Chat management for the Lark/Feishu channel plugin.
+ *
+ * Provides functions to update chat settings (name, avatar), manage
+ * members (add, remove, list) using the IM Chat API.
+ */
+/* eslint-disable @typescript-eslint/no-explicit-any */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateChatFeishu = updateChatFeishu;
+exports.addChatMembersFeishu = addChatMembersFeishu;
+exports.removeChatMembersFeishu = removeChatMembersFeishu;
+exports.listChatMembersFeishu = listChatMembersFeishu;
+const lark_client_1 = require("../../core/lark-client.js");
+// ---------------------------------------------------------------------------
+// Helpers
+// ---------------------------------------------------------------------------
+/** Assert that a Lark SDK response has code === 0 (or no code field). */
+function assertLarkOk(res, context) {
+    const code = res?.code;
+    if (code !== undefined && code !== 0) {
+        const msg = res?.msg ?? 'unknown error';
+        throw new Error(`[feishu-chat-manage] ${context}: code=${code}, msg=${msg}`);
+    }
+}
+// ---------------------------------------------------------------------------
+// updateChatFeishu
+// ---------------------------------------------------------------------------
+/**
+ * Update chat settings such as name or avatar.
+ */
+async function updateChatFeishu(params) {
+    const { cfg, chatId, name, avatar, accountId } = params;
+    const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+    const body = {};
+    if (name)
+        body.name = name;
+    if (avatar)
+        body.avatar = avatar;
+    const res = await client.im.chat.update({
+        path: { chat_id: chatId },
+        data: body,
+    });
+    assertLarkOk(res, `updateChat for ${chatId}`);
+}
+// ---------------------------------------------------------------------------
+// addChatMembersFeishu
+// ---------------------------------------------------------------------------
+/**
+ * Add members to a chat by their open_id list.
+ */
+async function addChatMembersFeishu(params) {
+    const { cfg, chatId, memberIds, accountId } = params;
+    const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+    const res = await client.im.v1.chatMembers.create({
+        path: { chat_id: chatId },
+        data: { id_list: memberIds },
+        params: { member_id_type: 'open_id' },
+    });
+    assertLarkOk(res, `addChatMembers for ${chatId}`);
+}
+// ---------------------------------------------------------------------------
+// removeChatMembersFeishu
+// ---------------------------------------------------------------------------
+/**
+ * Remove members from a chat by their open_id list.
+ */
+async function removeChatMembersFeishu(params) {
+    const { cfg, chatId, memberIds, accountId } = params;
+    const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+    const res = await client.im.v1.chatMembers.delete({
+        path: { chat_id: chatId },
+        data: { id_list: memberIds },
+        params: { member_id_type: 'open_id' },
+    });
+    assertLarkOk(res, `removeChatMembers for ${chatId}`);
+}
+// ---------------------------------------------------------------------------
+// listChatMembersFeishu
+// ---------------------------------------------------------------------------
+/**
+ * List members of a chat.
+ *
+ * Returns a single page (up to 100 members) to avoid unnecessary data
+ * overhead for large groups.  Use the returned `pageToken` to fetch
+ * subsequent pages when needed.
+ */
+async function listChatMembersFeishu(params) {
+    const { cfg, chatId, accountId, pageToken } = params;
+    const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+    const response = await client.im.v1.chatMembers.get({
+        path: { chat_id: chatId },
+        params: {
+            member_id_type: 'open_id',
+            page_size: 100,
+            ...(pageToken ? { page_token: pageToken } : {}),
+        },
+    });
+    assertLarkOk(response, `listChatMembers for ${chatId}`);
+    const members = [];
+    const items = response?.data?.items;
+    if (items && Array.isArray(items)) {
+        for (const item of items) {
+            members.push({
+                memberId: item.member_id ?? '',
+                name: item.name ?? '',
+                memberIdType: item.member_id_type ?? 'open_id',
+            });
+        }
+    }
+    const nextPageToken = response?.data?.page_token ?? undefined;
+    const hasMore = response?.data?.has_more === true && !!nextPageToken;
+    return { members, pageToken: nextPageToken, hasMore };
+}