@larksuite/openclaw-lark 2025.7.15-beta.0

package/src/messaging/outbound/send.js

@@ -0,0 +1,417 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Message sending for the Lark/Feishu channel plugin.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.sendMessageFeishu = sendMessageFeishu;
+exports.sendCardFeishu = sendCardFeishu;
+exports.updateCardFeishu = updateCardFeishu;
+exports.buildMarkdownCard = buildMarkdownCard;
+exports.buildI18nMarkdownCard = buildI18nMarkdownCard;
+exports.sendMarkdownCardFeishu = sendMarkdownCardFeishu;
+exports.editMessageFeishu = editMessageFeishu;
+const accounts_1 = require("../../core/accounts.js");
+const lark_client_1 = require("../../core/lark-client.js");
+const lark_logger_1 = require("../../core/lark-logger.js");
+const chat_queue_1 = require("../../channel/chat-queue.js");
+const targets_1 = require("../../core/targets.js");
+const message_unavailable_1 = require("../../core/message-unavailable.js");
+const markdown_style_1 = require("../../card/markdown-style.js");
+const mention_1 = require("../inbound/mention.js");
+const sentinel_store_1 = require("../inbound/sentinel-store.js");
+const normalize_mentions_1 = require("./normalize-mentions.js");
+const outbound_mention_1 = require("./outbound-mention.js");
+const bot_peer_context_1 = require("./bot-peer-context.js");
+const sendLog = (0, lark_logger_1.larkLogger)('outbound/send');
+/**
+ * Runs the outbound text through mention normalization. Returns the
+ * input unchanged on any failure so a parser bug never blocks send.
+ * Sentinels collected during normalization are returned for the caller
+ * to record after a successful send.
+ */
+async function normalizeFeishuOutboundText(cfg, to, text, accountId) {
+    if (!text?.trim())
+        return { text, sentinels: [], resolvedAccountId: accountId };
+    try {
+        const account = (0, accounts_1.getLarkAccount)(cfg, accountId ?? undefined);
+        const ctx = {
+            chatId: to,
+            account,
+            log: (...args) => sendLog.warn(args.map(String).join(' ')),
+        };
+        const r = await (0, normalize_mentions_1.normalizeOutboundMentions)(text, ctx);
+        let outText = r.normalizedText;
+        // Deterministic backstop on the real reply path: when this dispatch is
+        // replying to a designated bot peer (set via runWithBotPeerContext in the
+        // inbound dispatch), guarantee an @-mention so the peer actually receives
+        // the message even if the model didn't write one. No-op when no peer is
+        // in scope. De-duped across chunks: once the peer @ has appeared (whether
+        // the model wrote it or we injected it), later chunks of the same reply
+        // are left untouched so we don't @ on every chunk.
+        const peer = (0, bot_peer_context_1.currentBotPeerContext)();
+        if (peer && !peer.mentioned) {
+            outText = (0, outbound_mention_1.ensureMention)(outText, peer.peerOpenId, peer.peerName);
+            if (outText.includes(`user_id="${peer.peerOpenId}"`)) {
+                peer.mentioned = true;
+            }
+        }
+        return { text: outText, sentinels: r.sentinels, resolvedAccountId: account.accountId };
+    }
+    catch (err) {
+        sendLog.warn(`normalizeOutboundMentions failed, using raw text: ${String(err)}`);
+        return { text, sentinels: [], resolvedAccountId: accountId };
+    }
+}
+function recordFeishuSendSentinels(resolvedAccountId, to, threadId, sentinels) {
+    if (!resolvedAccountId || sentinels.length === 0)
+        return;
+    const threadKey = (0, chat_queue_1.threadScopedKey)(to, threadId);
+    (0, sentinel_store_1.getSentinelStore)(resolvedAccountId).recordSentinels(threadKey, sentinels);
+}
+// ---------------------------------------------------------------------------
+// sendMessageFeishu
+// ---------------------------------------------------------------------------
+/**
+ * Send a text message (rendered as a Feishu "post" with markdown support)
+ * to a chat or user.
+ *
+ * The message text is wrapped in Feishu's post format using the `md` tag
+ * for rich rendering. If `replyToMessageId` is provided, the message is
+ * sent as a threaded reply; otherwise it is sent as a new message using
+ * the appropriate `receive_id_type`.
+ *
+ * Markdown tables and code blocks are sent as-is so Feishu renders them
+ * natively in the post(`tag:md`); only `optimizeMarkdownStyle` is applied.
+ *
+ * @param params - See {@link SendFeishuMessageParams}.
+ * @returns The send result containing the new message ID.
+ */
+async function sendMessageFeishu(params) {
+    const { cfg, to, replyToMessageId, mentions, accountId, replyInThread, i18nTexts, threadId } = params;
+    let { text } = params;
+    // Mention normalization. Single-locale path rewrites `text`; the
+    // i18nTexts path rewrites each locale below. Sentinels are recorded
+    // after the send succeeds.
+    let normalizationSentinels = [];
+    let normalizationAccountId = accountId ?? undefined;
+    if (!i18nTexts && text?.trim()) {
+        const r = await normalizeFeishuOutboundText(cfg, to, text, accountId ?? undefined);
+        text = r.text;
+        normalizationSentinels = r.sentinels;
+        normalizationAccountId = r.resolvedAccountId;
+    }
+    const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+    // Build the post-format content envelope.
+    let contentPayload;
+    if (i18nTexts && Object.keys(i18nTexts).length > 0) {
+        // Multi-locale post: build each locale's content independently.
+        const postBody = {};
+        for (const [locale, localeText] of Object.entries(i18nTexts)) {
+            let processed = localeText;
+            // Apply mention prefix if targets are provided.
+            if (mentions && mentions.length > 0) {
+                processed = (0, mention_1.buildMentionedMessage)(mentions, processed);
+            }
+            // Apply Markdown style optimization.
+            processed = (0, markdown_style_1.optimizeMarkdownStyle)(processed, 1);
+            postBody[locale] = {
+                content: [[{ tag: 'md', text: processed }]],
+            };
+        }
+        contentPayload = JSON.stringify(postBody);
+    }
+    else {
+        // Single-locale (zh_cn) post: original behavior.
+        let messageText = text;
+        // Apply mention prefix if targets are provided.
+        if (mentions && mentions.length > 0) {
+            messageText = (0, mention_1.buildMentionedMessage)(mentions, messageText);
+        }
+        // Apply Markdown style optimization.
+        messageText = (0, markdown_style_1.optimizeMarkdownStyle)(messageText, 1);
+        contentPayload = JSON.stringify({
+            zh_cn: {
+                content: [[{ tag: 'md', text: messageText }]],
+            },
+        });
+    }
+    if (replyToMessageId) {
+        // Send as a threaded reply.
+        // 规范化 message_id，处理合成 ID（如 "om_xxx:auth-complete"）
+        const normalizedId = (0, targets_1.normalizeMessageId)(replyToMessageId);
+        const response = await (0, message_unavailable_1.runWithMessageUnavailableGuard)({
+            messageId: normalizedId,
+            operation: 'im.message.reply(post)',
+            fn: () => client.im.message.reply({
+                path: {
+                    message_id: normalizedId,
+                },
+                data: {
+                    content: contentPayload,
+                    msg_type: 'post',
+                    reply_in_thread: replyInThread,
+                },
+            }),
+        });
+        recordFeishuSendSentinels(normalizationAccountId, to, threadId, normalizationSentinels);
+        return {
+            messageId: response?.data?.message_id ?? '',
+            chatId: response?.data?.chat_id ?? '',
+        };
+    }
+    // Send as a new message.
+    const target = (0, targets_1.normalizeFeishuTarget)(to);
+    if (!target) {
+        throw new Error(`[feishu-send] Invalid target: "${to}"`);
+    }
+    const receiveIdType = (0, targets_1.resolveReceiveIdType)(target);
+    const response = await client.im.message.create({
+        params: {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            receive_id_type: receiveIdType,
+        },
+        data: {
+            receive_id: target,
+            msg_type: 'post',
+            content: contentPayload,
+        },
+    });
+    recordFeishuSendSentinels(normalizationAccountId, to, threadId, normalizationSentinels);
+    return {
+        messageId: response?.data?.message_id ?? '',
+        chatId: response?.data?.chat_id ?? '',
+    };
+}
+// ---------------------------------------------------------------------------
+// sendCardFeishu
+// ---------------------------------------------------------------------------
+/**
+ * Send an interactive card message to a chat or user.
+ *
+ * @param params - See {@link SendFeishuCardParams}.
+ * @returns The send result containing the new message ID.
+ */
+async function sendCardFeishu(params) {
+    const { cfg, to, card, replyToMessageId, accountId, replyInThread } = params;
+    const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+    const contentPayload = JSON.stringify(card);
+    if (replyToMessageId) {
+        // 规范化 message_id，处理合成 ID（如 "om_xxx:auth-complete"）
+        const normalizedId = (0, targets_1.normalizeMessageId)(replyToMessageId);
+        const response = await (0, message_unavailable_1.runWithMessageUnavailableGuard)({
+            messageId: normalizedId,
+            operation: 'im.message.reply(interactive)',
+            fn: () => client.im.message.reply({
+                path: {
+                    message_id: normalizedId,
+                },
+                data: {
+                    content: contentPayload,
+                    msg_type: 'interactive',
+                    reply_in_thread: replyInThread,
+                },
+            }),
+        });
+        return {
+            messageId: response?.data?.message_id ?? '',
+            chatId: response?.data?.chat_id ?? '',
+        };
+    }
+    const target = (0, targets_1.normalizeFeishuTarget)(to);
+    if (!target) {
+        throw new Error(`[feishu-send] Invalid target: "${to}"`);
+    }
+    const receiveIdType = (0, targets_1.resolveReceiveIdType)(target);
+    const response = await client.im.message.create({
+        params: {
+            // eslint-disable-next-line @typescript-eslint/no-explicit-any
+            receive_id_type: receiveIdType,
+        },
+        data: {
+            receive_id: target,
+            msg_type: 'interactive',
+            content: contentPayload,
+        },
+    });
+    return {
+        messageId: response?.data?.message_id ?? '',
+        chatId: response?.data?.chat_id ?? '',
+    };
+}
+// ---------------------------------------------------------------------------
+// updateCardFeishu
+// ---------------------------------------------------------------------------
+/**
+ * Update (PATCH) the content of an existing interactive card message.
+ *
+ * Only messages originally sent by the bot can be updated. The card
+ * must have been created with `"update_multi": true` in its config if
+ * all recipients should see the update.
+ *
+ * @param params.cfg       - Plugin configuration.
+ * @param params.messageId - The card message ID to update.
+ * @param params.card      - The new card content.
+ * @param params.accountId - Optional account identifier.
+ */
+async function updateCardFeishu(params) {
+    const { cfg, messageId, card, accountId } = params;
+    const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+    await (0, message_unavailable_1.runWithMessageUnavailableGuard)({
+        messageId,
+        operation: 'im.message.patch(interactive)',
+        fn: () => client.im.message.patch({
+            path: {
+                message_id: messageId,
+            },
+            data: {
+                content: JSON.stringify(card),
+            },
+        }),
+    });
+}
+// ---------------------------------------------------------------------------
+// buildMarkdownCard
+// ---------------------------------------------------------------------------
+/**
+ * Build a simple Feishu Interactive Message Card containing a single
+ * markdown element.
+ *
+ * This is a convenience wrapper for the most common card layout: a
+ * wide-screen card with one markdown block.
+ *
+ * @param text - The markdown text to render in the card.
+ * @returns A card JSON object ready to be sent via {@link sendCardFeishu}.
+ */
+function buildMarkdownCard(text) {
+    const optimizedText = (0, markdown_style_1.optimizeMarkdownStyle)(text);
+    return {
+        schema: '2.0',
+        config: {
+            wide_screen_mode: true,
+        },
+        body: {
+            elements: [
+                {
+                    tag: 'markdown',
+                    content: optimizedText,
+                },
+            ],
+        },
+    };
+}
+/**
+ * Build an i18n-aware Feishu Interactive Message Card containing a single
+ * markdown element with per-locale content.
+ *
+ * Uses the CardKit v2 `i18n_content` field so the Feishu client
+ * auto-selects the locale matching the user's language setting.
+ *
+ * @param i18nTexts - A map of locale to markdown text (e.g. { zh_cn: '...', en_us: '...' }).
+ * @returns A card JSON object ready to be sent via {@link sendCardFeishu}.
+ */
+function buildI18nMarkdownCard(i18nTexts) {
+    const locales = Object.keys(i18nTexts);
+    // Determine fallback content (prefer en_us, then first available locale).
+    const fallbackLocale = locales.includes('en_us') ? 'en_us' : locales[0];
+    const fallbackText = (0, markdown_style_1.optimizeMarkdownStyle)(i18nTexts[fallbackLocale]);
+    // Build i18n_content with optimized text for each locale.
+    const i18nContent = {};
+    for (const [locale, text] of Object.entries(i18nTexts)) {
+        i18nContent[locale] = (0, markdown_style_1.optimizeMarkdownStyle)(text);
+    }
+    return {
+        schema: '2.0',
+        config: {
+            wide_screen_mode: true,
+        },
+        body: {
+            elements: [
+                {
+                    tag: 'markdown',
+                    content: fallbackText,
+                    i18n_content: i18nContent,
+                },
+            ],
+        },
+    };
+}
+// ---------------------------------------------------------------------------
+// sendMarkdownCardFeishu
+// ---------------------------------------------------------------------------
+/**
+ * Build a markdown card and send it in one step.
+ *
+ * If mention targets are provided, they are prepended to the markdown
+ * content using the card mention syntax.
+ *
+ * @param params.cfg              - Plugin configuration.
+ * @param params.to               - Target identifier.
+ * @param params.text             - Markdown content for the card.
+ * @param params.replyToMessageId - Optional message ID for threaded reply.
+ * @param params.mentions         - Optional mention targets.
+ * @param params.accountId        - Optional account identifier.
+ * @returns The send result containing the new message ID.
+ */
+async function sendMarkdownCardFeishu(params) {
+    const { cfg, to, text, replyToMessageId, mentions, accountId, replyInThread } = params;
+    // Normalize @-mentions and apply the bot-peer ensureMention backstop on the
+    // card path too (mirrors sendMessageFeishu), so a reply rendered as a card
+    // still reaches the designated peer bot.
+    const normalized = await normalizeFeishuOutboundText(cfg, to, text, accountId ?? undefined);
+    let cardText = normalized.text;
+    if (mentions && mentions.length > 0) {
+        cardText = (0, mention_1.buildMentionedCardContent)(mentions, cardText);
+    }
+    const card = buildMarkdownCard(cardText);
+    const result = await sendCardFeishu({
+        cfg,
+        to,
+        card,
+        replyToMessageId,
+        replyInThread,
+        accountId,
+    });
+    recordFeishuSendSentinels(normalized.resolvedAccountId, to, undefined, normalized.sentinels);
+    return result;
+}
+// ---------------------------------------------------------------------------
+// editMessageFeishu
+// ---------------------------------------------------------------------------
+/**
+ * Edit the content of an existing message.
+ *
+ * Updates the message body via the IM message update API. Only
+ * messages sent by the bot can be edited.
+ *
+ * @param params.cfg       - Plugin configuration.
+ * @param params.messageId - The message ID to edit.
+ * @param params.text      - The new message text.
+ * @param params.accountId - Optional account identifier.
+ */
+async function editMessageFeishu(params) {
+    const { cfg, messageId, text, accountId } = params;
+    const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+    // Use cardVersion=1 consistent with sendMessageFeishu post path.
+    const optimizedText = (0, markdown_style_1.optimizeMarkdownStyle)(text, 1);
+    const contentPayload = JSON.stringify({
+        zh_cn: {
+            content: [[{ tag: 'md', text: optimizedText }]],
+        },
+    });
+    await (0, message_unavailable_1.runWithMessageUnavailableGuard)({
+        messageId,
+        operation: 'im.message.update(post)',
+        fn: () => client.im.message.update({
+            path: {
+                message_id: messageId,
+            },
+            data: {
+                content: contentPayload,
+                msg_type: 'post',
+            },
+        }),
+    });
+}

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

@@ -0,0 +1,60 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Typing indicator management for the Lark/Feishu channel plugin.
+ *
+ * Feishu does not expose a first-class "typing indicator" API the way
+ * some other messaging platforms do. Instead, this module simulates a
+ * typing state by adding a recognisable emoji reaction (the "Typing"
+ * emoji) to the user's message while the bot is processing, and
+ * removing it once the response is ready.
+ *
+ * This provides a lightweight visual cue that the bot has acknowledged
+ * the message and is working on a reply.
+ */
+import type { OpenClawConfig } from 'openclaw/plugin-sdk';
+/**
+ * Tracks the state of an active typing indicator so it can be
+ * removed later.
+ */
+export interface TypingIndicatorState {
+    /** The message ID that the reaction was added to. */
+    messageId: string;
+    /** The reaction ID returned by the API, or null if the add failed. */
+    reactionId: string | null;
+}
+/**
+ * Add a typing indicator to a message by creating an emoji reaction.
+ *
+ * The reaction is added silently -- any errors (network issues, missing
+ * permissions, rate limits) are caught and logged rather than propagated
+ * to the caller. This ensures that a failure to show the typing cue
+ * never blocks the actual message processing.
+ *
+ * @param params.cfg       - Plugin configuration with Feishu credentials.
+ * @param params.messageId - The message ID to add the typing reaction to.
+ * @param params.accountId - Optional account identifier for multi-account setups.
+ * @returns A state object that should be passed to {@link removeTypingIndicator}.
+ */
+export declare function addTypingIndicator(params: {
+    cfg: OpenClawConfig;
+    messageId: string;
+    accountId?: string;
+}): Promise<TypingIndicatorState>;
+/**
+ * Remove a previously added typing indicator reaction from a message.
+ *
+ * If the indicator was never successfully added (reactionId is null),
+ * this function is a no-op. Errors are silently caught so removal
+ * failures do not disrupt downstream logic.
+ *
+ * @param params.cfg   - Plugin configuration with Feishu credentials.
+ * @param params.state - The typing indicator state returned by {@link addTypingIndicator}.
+ * @param params.accountId - Optional account identifier for multi-account setups.
+ */
+export declare function removeTypingIndicator(params: {
+    cfg: OpenClawConfig;
+    state: TypingIndicatorState;
+    accountId?: string;
+}): Promise<void>;

package/src/messaging/outbound/typing.js

@@ -0,0 +1,139 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Typing indicator management for the Lark/Feishu channel plugin.
+ *
+ * Feishu does not expose a first-class "typing indicator" API the way
+ * some other messaging platforms do. Instead, this module simulates a
+ * typing state by adding a recognisable emoji reaction (the "Typing"
+ * emoji) to the user's message while the bot is processing, and
+ * removing it once the response is ready.
+ *
+ * This provides a lightweight visual cue that the bot has acknowledged
+ * the message and is working on a reply.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.addTypingIndicator = addTypingIndicator;
+exports.removeTypingIndicator = removeTypingIndicator;
+const lark_client_1 = require("../../core/lark-client.js");
+const targets_1 = require("../../core/targets.js");
+const message_unavailable_1 = require("../../core/message-unavailable.js");
+const lark_logger_1 = require("../../core/lark-logger.js");
+const log = (0, lark_logger_1.larkLogger)('outbound/typing');
+// ---------------------------------------------------------------------------
+// Constants
+// ---------------------------------------------------------------------------
+/**
+ * The emoji type used to represent the typing indicator.
+ *
+ * "Typing" is a built-in Feishu emoji that shows a pencil / keyboard
+ * animation, making it a natural choice for a typing cue.
+ */
+const TYPING_EMOJI_TYPE = 'Typing';
+// ---------------------------------------------------------------------------
+// addTypingIndicator
+// ---------------------------------------------------------------------------
+/**
+ * Add a typing indicator to a message by creating an emoji reaction.
+ *
+ * The reaction is added silently -- any errors (network issues, missing
+ * permissions, rate limits) are caught and logged rather than propagated
+ * to the caller. This ensures that a failure to show the typing cue
+ * never blocks the actual message processing.
+ *
+ * @param params.cfg       - Plugin configuration with Feishu credentials.
+ * @param params.messageId - The message ID to add the typing reaction to.
+ * @param params.accountId - Optional account identifier for multi-account setups.
+ * @returns A state object that should be passed to {@link removeTypingIndicator}.
+ */
+async function addTypingIndicator(params) {
+    const { cfg, messageId, accountId } = params;
+    // 规范化 message_id，处理合成 ID（如 "om_xxx:auth-complete"）
+    const normalizedId = (0, targets_1.normalizeMessageId)(messageId);
+    const state = {
+        messageId: normalizedId, // 保存规范化后的 ID
+        reactionId: null,
+    };
+    try {
+        const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+        const response = await (0, message_unavailable_1.runWithMessageUnavailableGuard)({
+            messageId: normalizedId,
+            operation: 'im.messageReaction.create(typing)',
+            fn: () => client.im.messageReaction.create({
+                path: {
+                    message_id: normalizedId,
+                },
+                data: {
+                    reaction_type: {
+                        emoji_type: TYPING_EMOJI_TYPE,
+                    },
+                },
+            }),
+        });
+        state.reactionId = response?.data?.reaction_id ?? null;
+    }
+    catch (error) {
+        if ((0, message_unavailable_1.isMessageUnavailableError)(error)) {
+            log.debug(`Skip add typing indicator for unavailable message`, { messageId: normalizedId });
+            return state;
+        }
+        // Silently swallow the error. The typing indicator is a best-effort
+        // visual cue and must not interfere with message processing.
+        log.debug(`Failed to add typing indicator`, {
+            messageId,
+            error: error instanceof Error ? error.message : error,
+        });
+    }
+    return state;
+}
+// ---------------------------------------------------------------------------
+// removeTypingIndicator
+// ---------------------------------------------------------------------------
+/**
+ * Remove a previously added typing indicator reaction from a message.
+ *
+ * If the indicator was never successfully added (reactionId is null),
+ * this function is a no-op. Errors are silently caught so removal
+ * failures do not disrupt downstream logic.
+ *
+ * @param params.cfg   - Plugin configuration with Feishu credentials.
+ * @param params.state - The typing indicator state returned by {@link addTypingIndicator}.
+ * @param params.accountId - Optional account identifier for multi-account setups.
+ */
+async function removeTypingIndicator(params) {
+    const { cfg, state, accountId } = params;
+    const reactionId = state.reactionId;
+    if (!reactionId) {
+        // Nothing to remove -- the indicator was never added or the add
+        // call did not return a reaction ID.
+        return;
+    }
+    try {
+        const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
+        await (0, message_unavailable_1.runWithMessageUnavailableGuard)({
+            messageId: state.messageId,
+            operation: 'im.messageReaction.delete(typing)',
+            fn: () => client.im.messageReaction.delete({
+                path: {
+                    message_id: state.messageId,
+                    reaction_id: reactionId,
+                },
+            }),
+        });
+    }
+    catch (error) {
+        if ((0, message_unavailable_1.isMessageUnavailableError)(error)) {
+            log.debug(`Skip remove typing indicator for unavailable message`, { messageId: state.messageId });
+            return;
+        }
+        // Silently swallow the error. A leftover reaction is acceptable;
+        // it will not confuse the user and will disappear if the message
+        // is deleted or the reaction is manually removed.
+        log.debug(`Failed to remove typing indicator`, {
+            messageId: state.messageId,
+            error: error instanceof Error ? error.message : error,
+        });
+    }
+}

package/src/messaging/shared/message-lookup.d.ts

@@ -0,0 +1,54 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Message fetching for the Lark/Feishu channel plugin.
+ *
+ * Shared between inbound (reaction handler, enrich) and outbound modules.
+ * Extracted from `outbound/fetch.ts` to eliminate inbound→outbound
+ * dependency inversion.
+ */
+import type { ClawdbotConfig } from 'openclaw/plugin-sdk';
+/**
+ * Normalised information about a Feishu message, returned by
+ * {@link getMessageFeishu}.
+ */
+export interface FeishuMessageInfo {
+    /** Unique Feishu message ID. */
+    messageId: string;
+    /** Chat ID where the message lives. */
+    chatId: string;
+    /** Chat type ("p2p" or "group"), when available in the API response. */
+    chatType?: string;
+    /** Open ID of the sender (if available). */
+    senderId?: string;
+    /** Display name of the sender (resolved from user-name cache). */
+    senderName?: string;
+    /** Feishu sender type: "user" for human users, "app" for bots/apps. */
+    senderType?: string;
+    /** The parsed text / content of the message. */
+    content: string;
+    /** Feishu content type indicator (text, post, image, interactive, ...). */
+    contentType: string;
+    /** Unix-millisecond timestamp of when the message was created. */
+    createTime?: number;
+    /** Thread ID if the message belongs to a thread (omt_xxx format). */
+    threadId?: string;
+}
+/**
+ * Retrieve a single message by its ID from the Feishu IM API.
+ *
+ * Returns a normalised {@link FeishuMessageInfo} object, or `null` if the
+ * message cannot be found or the API returns an error.
+ *
+ * @param params.cfg       - Plugin configuration with Feishu credentials.
+ * @param params.messageId - The message ID to fetch.
+ * @param params.accountId - Optional account identifier for multi-account setups.
+ */
+export declare function getMessageFeishu(params: {
+    cfg: ClawdbotConfig;
+    messageId: string;
+    accountId?: string;
+    /** When true, merge_forward content is recursively expanded via API. */
+    expandForward?: boolean;
+}): Promise<FeishuMessageInfo | null>;