@colinlu50/openclaw-lark-stream 2026.3.17

package/src/messaging/outbound/actions.js

@@ -0,0 +1,309 @@
+/**
+ * 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.
+ */
+import { extractToolSend, jsonResult, readStringParam, readReactionParams } from 'openclaw/plugin-sdk';
+import { addReactionFeishu, removeReactionFeishu, listReactionsFeishu } from './reactions';
+import { sendTextLark, sendCardLark } from './deliver';
+import { uploadAndSendMediaLark } from './media';
+import { LarkClient } from '../../core/lark-client';
+import { getEnabledLarkAccounts } from '../../core/accounts';
+import { larkLogger } from '../../core/lark-logger';
+const log = larkLogger('outbound/actions');
+// ---------------------------------------------------------------------------
+// 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.
+    if (typeof raw === 'object' && !Array.isArray(raw)) {
+        return raw;
+    }
+    // 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 = readStringParam(params, 'to') ?? '';
+    const text = readStringParam(params, 'message', { allowEmpty: true }) ??
+        readStringParam(params, 'text', { allowEmpty: true }) ??
+        '';
+    const mediaUrl = readStringParam(params, 'media') ??
+        readStringParam(params, 'path') ??
+        readStringParam(params, 'filePath') ??
+        readStringParam(params, 'url');
+    const fileName = readStringParam(params, 'fileName') ?? 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 = 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
+// ---------------------------------------------------------------------------
+export const feishuMessageActions = {
+    listActions: ({ cfg }) => {
+        const accounts = getEnabledLarkAccounts(cfg);
+        if (accounts.length === 0)
+            return [];
+        return Array.from(SUPPORTED_ACTIONS);
+    },
+    supportsAction: ({ action }) => SUPPORTED_ACTIONS.has(action),
+    supportsButtons: ({ cfg }) => getEnabledLarkAccounts(cfg).length > 0,
+    supportsCards: ({ cfg }) => getEnabledLarkAccounts(cfg).length > 0,
+    extractToolSend: ({ args }) => 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 sendTextLark({ ...sendCtx, text });
+    }
+    // Card path.
+    if (card) {
+        const result = await sendCardLark({ ...sendCtx, card });
+        log.info(`deliverMessage: card sent, messageId=${result.messageId}`);
+        return 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 sendTextLark({ ...sendCtx, text });
+    log.info(`deliverMessage: text sent, messageId=${result.messageId}`);
+    return 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 uploadAndSendMediaLark({
+            cfg,
+            to,
+            mediaUrl,
+            fileName,
+            replyToMessageId,
+            replyInThread,
+            accountId,
+            mediaLocalRoots,
+        });
+        log.info(`deliverMedia: sent, messageId=${result.messageId}`);
+        return 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 sendTextLark({
+            cfg,
+            to,
+            text: `> ${mediaUrl}`,
+            replyToMessageId,
+            replyInThread,
+            accountId,
+        });
+        return 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 = readStringParam(params, 'messageId', { required: true });
+    const { emoji, remove, isEmpty } = 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 listReactionsFeishu({
+            cfg,
+            messageId,
+            emojiType: emoji || undefined,
+            accountId,
+        });
+        const botReactions = reactions.filter((r) => r.operatorType === 'app');
+        for (const r of botReactions) {
+            await removeReactionFeishu({
+                cfg,
+                messageId,
+                reactionId: r.reactionId,
+                accountId,
+            });
+        }
+        log.info(`react: removed ${botReactions.length} bot reaction(s)`);
+        return jsonResult({ ok: true, removed: botReactions.length });
+    }
+    log.info(`react: adding emoji=${emoji} to messageId=${messageId}`);
+    const { reactionId } = await addReactionFeishu({
+        cfg,
+        messageId,
+        emojiType: emoji,
+        accountId,
+    });
+    log.info(`react: added reactionId=${reactionId}`);
+    return jsonResult({ ok: true, reactionId });
+}
+async function handleReactions(cfg, params, accountId) {
+    const messageId = readStringParam(params, 'messageId', { required: true });
+    const emojiType = readStringParam(params, 'emoji');
+    const reactions = await listReactionsFeishu({
+        cfg,
+        messageId,
+        emojiType: emojiType || undefined,
+        accountId,
+    });
+    return 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 = readStringParam(params, 'messageId', { required: true });
+    log.info(`delete: messageId=${messageId}`);
+    const client = 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 jsonResult({ ok: true, messageId, deleted: true });
+}

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,111 @@
+/**
+ * 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 */
+import { LarkClient } from '../../core/lark-client';
+// ---------------------------------------------------------------------------
+// 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.
+ */
+export async function updateChatFeishu(params) {
+    const { cfg, chatId, name, avatar, accountId } = params;
+    const client = 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.
+ */
+export async function addChatMembersFeishu(params) {
+    const { cfg, chatId, memberIds, accountId } = params;
+    const client = 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.
+ */
+export async function removeChatMembersFeishu(params) {
+    const { cfg, chatId, memberIds, accountId } = params;
+    const client = 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.
+ */
+export async function listChatMembersFeishu(params) {
+    const { cfg, chatId, accountId, pageToken } = params;
+    const client = 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 };
+}

package/src/messaging/outbound/deliver.d.ts

@@ -0,0 +1,155 @@
+/**
+ * Standalone text and media delivery functions for the Lark/Feishu channel.
+ *
+ * These functions operate directly on the Lark SDK without depending on
+ * {@link sendMessageFeishu} from `send.ts`. The outbound adapter delegates
+ * to these for its `sendText` and `sendMedia` implementations.
+ */
+import type { ClawdbotConfig } from 'openclaw/plugin-sdk';
+import type { FeishuSendResult } from '../types';
+/**
+ * Parameters for sending a text message via Feishu.
+ */
+export interface SendTextLarkParams {
+    /** Plugin configuration. */
+    cfg: ClawdbotConfig;
+    /** Target identifier (chat_id, open_id, or user_id). */
+    to: string;
+    /** Message text content (supports Feishu markdown subset). */
+    text: string;
+    /** When set, the message is sent as a threaded reply. */
+    replyToMessageId?: string;
+    /** When true, the reply appears in the thread instead of main chat. */
+    replyInThread?: boolean;
+    /** Optional account identifier for multi-account setups. */
+    accountId?: string;
+}
+/**
+ * Send a text message to a Feishu chat or user.
+ *
+ * Standalone implementation that directly operates the Lark SDK.
+ * The text is pre-processed (table conversion, style optimization)
+ * and sent as a Feishu "post" message with markdown rendering.
+ *
+ * If the entire text is a valid Feishu card JSON string (v1 or v2),
+ * it is automatically detected and routed to {@link sendCardLark}
+ * instead of being sent as plain text.
+ *
+ * @param params - See {@link SendTextLarkParams}.
+ * @returns The message ID and chat ID.
+ * @throws {Error} When the target is invalid or the API call fails.
+ *
+ * @example
+ * ```ts
+ * const result = await sendTextLark({
+ *   cfg,
+ *   to: "oc_xxx",
+ *   text: "Hello from Feishu",
+ * });
+ * ```
+ */
+export declare function sendTextLark(params: SendTextLarkParams): Promise<FeishuSendResult>;
+/**
+ * Parameters for sending an interactive card message via Feishu.
+ */
+export interface SendCardLarkParams {
+    /** Plugin configuration. */
+    cfg: ClawdbotConfig;
+    /** Target identifier (chat_id, open_id, or user_id). */
+    to: string;
+    /**
+     * Complete card JSON object (v1 Message Card or v2 CardKit).
+     *
+     * - **v1**: top-level `config`, `header`, `elements`.
+     * - **v2**: `schema: "2.0"`, `config`, `header`, `body.elements`.
+     *
+     * The Feishu server determines the version by the presence of
+     * `schema: "2.0"`.
+     */
+    card: Record<string, unknown>;
+    /** When set, the card is sent as a threaded reply. */
+    replyToMessageId?: string;
+    /** When true, the reply appears in the thread instead of main chat. */
+    replyInThread?: boolean;
+    /** Optional account identifier for multi-account setups. */
+    accountId?: string;
+}
+/**
+ * Send an interactive card message to a Feishu chat or user.
+ *
+ * Supports both v1 (Message Card) and v2 (CardKit) card formats.
+ * The card JSON is serialised and sent as `msg_type: "interactive"`.
+ *
+ * @param params - See {@link SendCardLarkParams}.
+ * @returns The message ID and chat ID.
+ * @throws {Error} When the target is invalid or the API call fails.
+ *
+ * @example
+ * ```ts
+ * // v1 card
+ * const result = await sendCardLark({
+ *   cfg,
+ *   to: "oc_xxx",
+ *   card: {
+ *     config: { wide_screen_mode: true },
+ *     header: { title: { tag: "plain_text", content: "Hello" }, template: "blue" },
+ *     elements: [{ tag: "div", text: { tag: "lark_md", content: "world" } }],
+ *   },
+ * });
+ *
+ * // v2 card
+ * const result2 = await sendCardLark({
+ *   cfg,
+ *   to: "oc_xxx",
+ *   card: {
+ *     schema: "2.0",
+ *     config: { wide_screen_mode: true },
+ *     body: { elements: [{ tag: "markdown", content: "Hello **world**" }] },
+ *   },
+ * });
+ * ```
+ */
+export declare function sendCardLark(params: SendCardLarkParams): Promise<FeishuSendResult>;
+/**
+ * Parameters for sending a single media message via Feishu.
+ */
+export interface SendMediaLarkParams {
+    /** Plugin configuration. */
+    cfg: ClawdbotConfig;
+    /** Target identifier (chat_id, open_id, or user_id). */
+    to: string;
+    /** Media URL to upload and send. */
+    mediaUrl: string;
+    /** When set, the message is sent as a threaded reply. */
+    replyToMessageId?: string;
+    /** When true, the reply appears in the thread instead of main chat. */
+    replyInThread?: boolean;
+    /** Optional account identifier for multi-account setups. */
+    accountId?: string;
+    /** Allowed root directories for local file access (SSRF prevention). */
+    mediaLocalRoots?: readonly string[];
+}
+/**
+ * Send a single media message to a Feishu chat or user.
+ *
+ * Pure atomic operation — uploads the media and sends it. On upload
+ * failure, falls back to sending the URL as a clickable text link.
+ *
+ * This function does **not** handle leading text or multi-media
+ * orchestration; those concerns belong to the adapter's `sendMedia`
+ * and `sendPayload` methods.
+ *
+ * @param params - See {@link SendMediaLarkParams}.
+ * @returns The message ID and chat ID of the sent message.
+ * @throws {Error} When the target is invalid or all send attempts fail.
+ *
+ * @example
+ * ```ts
+ * const result = await sendMediaLark({
+ *   cfg,
+ *   to: "oc_xxx",
+ *   mediaUrl: "https://example.com/image.png",
+ * });
+ * ```
+ */
+export declare function sendMediaLark(params: SendMediaLarkParams): Promise<FeishuSendResult>;