@larksuite/openclaw-lark 2026.6.10 → 2026.7.9-beta.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@larksuite/openclaw-lark",
-  "version": "2026.6.10",
+  "version": "2026.7.9-beta.0",
   "description": "OpenClaw Lark/Feishu channel plugin",
   "exports": {
     ".": {

package/src/card/reply-dispatcher.js

@@ -37,8 +37,6 @@ function createFeishuReplyDispatcher(params) {
     // Resolve account so we can read per-account config (e.g. replyMode)
     const account = (0, accounts_1.getLarkAccount)(cfg, accountId);
     const feishuCfg = account.config;
-    // accountScopedCfg 用于需要 account-level 覆盖的配置项（如 tableMode）
-    const accountScopedCfg = (0, accounts_1.createAccountScopedConfig)(cfg, account.accountId);
     const prefixContext = (0, channel_runtime_1.createReplyPrefixContext)({ cfg, agentId });
     // ---- Reply mode resolution ----
     const chatType = params.chatType;
@@ -69,11 +67,6 @@ function createFeishuReplyDispatcher(params) {
     // ---- Chunk & render settings (static mode only) ----
     const textChunkLimit = core.channel.text.resolveTextChunkLimit(cfg, 'feishu', accountId, { fallbackLimit: 4000 });
     const chunkMode = core.channel.text.resolveChunkMode(cfg, 'feishu');
-    // 使用 accountScopedCfg 以支持 per-account tableMode 覆盖
-    const tableMode = core.channel.text.resolveMarkdownTableMode({
-        cfg: accountScopedCfg,
-        channel: 'feishu',
-    });
     // ---- Streaming card controller (instantiated only when needed) ----
     const controller = useStreamingCards
         ? new streaming_card_controller_1.StreamingCardController({
@@ -300,8 +293,7 @@ function createFeishuReplyDispatcher(params) {
                     }
                 }
                 else {
-                    const converted = core.channel.text.convertMarkdownTables(text, tableMode);
-                    const chunks = core.channel.text.chunkTextWithMode(converted, textChunkLimit, chunkMode);
+                    const chunks = core.channel.text.chunkTextWithMode(text, textChunkLimit, chunkMode);
                     log.info('deliver: sending text chunks', {
                         count: chunks.length,
                         chatId,

package/src/card/reply-mode.d.ts

@@ -30,9 +30,12 @@ export declare function expandAutoMode(params: {
     chatType?: 'p2p' | 'group';
 }): 'static' | 'streaming';
 /**
- * Detect whether the text contains markdown elements that benefit from
- * being rendered inside a Feishu interactive card (fenced code blocks or
- * markdown tables).
+ * scope A: rich text now renders natively as post(`tag:md`); we never force a
+ * card for code blocks OR tables anymore. Native rendering also keeps bot-at-bot
+ * @ delivery working — wrapping a reply in a card breaks it (cards have limited
+ * @ support). The only remaining card-path guard is the table-count hard limit,
+ * retained for the runtime fallback in reply-dispatcher (card rejected by
+ * Feishu → plain text).
  */
 export declare function shouldUseCard(text: string): boolean;
 export {};

package/src/card/reply-mode.js

@@ -54,26 +54,17 @@ function expandAutoMode(params) {
 // shouldUseCard
 // ---------------------------------------------------------------------------
 /**
- * Detect whether the text contains markdown elements that benefit from
- * being rendered inside a Feishu interactive card (fenced code blocks or
- * markdown tables).
+ * scope A: rich text now renders natively as post(`tag:md`); we never force a
+ * card for code blocks OR tables anymore. Native rendering also keeps bot-at-bot
+ * @ delivery working — wrapping a reply in a card breaks it (cards have limited
+ * @ support). The only remaining card-path guard is the table-count hard limit,
+ * retained for the runtime fallback in reply-dispatcher (card rejected by
+ * Feishu → plain text).
  */
 function shouldUseCard(text) {
-    // Markdown tables NO LONGER force a card. Feishu messages render markdown
-    // tables natively, and wrapping a reply in a card breaks bot-at-bot @
-    // delivery (cards have limited @ support). Only fenced code blocks still
-    // benefit from card rendering.
-    //
-    // The table-count guard is kept as a safety valve: when a reply also
-    // contains an excessive number of markdown tables, skip the card entirely
-    // rather than risk a card-render failure.
     const tableMatches = (0, card_error_1.findMarkdownTablesOutsideCodeBlocks)(text);
     if (tableMatches.length > card_error_1.FEISHU_CARD_TABLE_LIMIT) {
         return false;
     }
-    // Fenced code blocks
-    if (/```[\s\S]*?```/.test(text)) {
-        return true;
-    }
     return false;
 }

package/src/channel/abort-detect.js

@@ -180,7 +180,10 @@ function isConversationStopIntent(text) {
     if (!text)
         return false;
     // Drop bot mention placeholders so "@Bot 中断对话" → "中断对话".
-    const normalized = text.replace(/@_user_\d+/g, '').trim().toLowerCase();
+    const normalized = text
+        .replace(/@_user_\d+/g, '')
+        .trim()
+        .toLowerCase();
     if (!normalized)
         return false;
     if (isLikelyAbortText(normalized))

package/src/channel/interactive-dispatch.js

@@ -23,7 +23,7 @@ const log = (0, lark_logger_1.larkLogger)('channel/interactive-dispatch');
 function extractBasics(data) {
     try {
         const ev = data;
-        const action = ev.action?.value?.action;
+        const action = ev.action?.value?.action ?? ev.action?.name;
         if (!action || typeof action !== 'string')
             return null;
         const openChatId = ev.open_chat_id ?? ev.context?.open_chat_id;
@@ -172,6 +172,7 @@ async function dispatchFeishuPluginInteractiveHandler(params) {
                 return { handled: cardResponse !== undefined };
             },
         });
+        log.debug(`interactive dispatch result: action=${basics.action}, matched=${result.matched}, handled=${result.handled}`);
         if (!result.matched)
             return undefined;
         return cardResponse;

package/src/core/config-schema.d.ts

@@ -9,477 +9,10 @@
  */
 import { z } from 'zod';
 export { z };
-export declare const UATConfigSchema: z.ZodOptional<z.ZodObject<{
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    allowedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    blockedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-}, z.core.$strip>>;
-export declare const FeishuGroupSchema: z.ZodObject<{
-    groupPolicy: z.ZodOptional<z.ZodEnum<{
-        open: "open";
-        allowlist: "allowlist";
-        disabled: "disabled";
-    }>>;
-    requireMention: z.ZodOptional<z.ZodBoolean>;
-    respondToMentionAll: z.ZodOptional<z.ZodBoolean>;
-    tools: z.ZodOptional<z.ZodObject<{
-        allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-    skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    allowFrom: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
-    systemPrompt: z.ZodOptional<z.ZodString>;
-    allowBots: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"mentions">]>>;
-    replyInThread: z.ZodOptional<z.ZodBoolean>;
-}, z.core.$strip>;
-export declare const FeishuAccountConfigSchema: z.ZodObject<{
-    appId: z.ZodOptional<z.ZodString>;
-    appSecret: z.ZodOptional<z.ZodString>;
-    encryptKey: z.ZodOptional<z.ZodString>;
-    verificationToken: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    domain: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"feishu">, z.ZodLiteral<"lark">, z.ZodString]>>;
-    connectionMode: z.ZodOptional<z.ZodEnum<{
-        websocket: "websocket";
-        webhook: "webhook";
-    }>>;
-    webhookPath: z.ZodOptional<z.ZodString>;
-    webhookPort: z.ZodOptional<z.ZodNumber>;
-    dmPolicy: z.ZodOptional<z.ZodEnum<{
-        open: "open";
-        pairing: "pairing";
-        allowlist: "allowlist";
-        disabled: "disabled";
-    }>>;
-    allowFrom: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
-    groupPolicy: z.ZodOptional<z.ZodEnum<{
-        open: "open";
-        allowlist: "allowlist";
-        disabled: "disabled";
-    }>>;
-    groupAllowFrom: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
-    requireMention: z.ZodOptional<z.ZodBoolean>;
-    respondToMentionAll: z.ZodOptional<z.ZodBoolean>;
-    groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        groupPolicy: z.ZodOptional<z.ZodEnum<{
-            open: "open";
-            allowlist: "allowlist";
-            disabled: "disabled";
-        }>>;
-        requireMention: z.ZodOptional<z.ZodBoolean>;
-        respondToMentionAll: z.ZodOptional<z.ZodBoolean>;
-        tools: z.ZodOptional<z.ZodObject<{
-            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        allowFrom: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
-        systemPrompt: z.ZodOptional<z.ZodString>;
-        allowBots: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"mentions">]>>;
-        replyInThread: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-    historyLimit: z.ZodOptional<z.ZodNumber>;
-    dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
-    dms: z.ZodOptional<z.ZodObject<{
-        historyLimit: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    textChunkLimit: z.ZodOptional<z.ZodNumber>;
-    chunkMode: z.ZodOptional<z.ZodEnum<{
-        newline: "newline";
-        paragraph: "paragraph";
-        none: "none";
-    }>>;
-    blockStreamingCoalesce: z.ZodOptional<z.ZodObject<{
-        minChars: z.ZodOptional<z.ZodNumber>;
-        maxChars: z.ZodOptional<z.ZodNumber>;
-        idleMs: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    mediaMaxMb: z.ZodOptional<z.ZodNumber>;
-    heartbeat: z.ZodOptional<z.ZodObject<{
-        every: z.ZodOptional<z.ZodString>;
-        activeHours: z.ZodOptional<z.ZodObject<{
-            start: z.ZodOptional<z.ZodString>;
-            end: z.ZodOptional<z.ZodString>;
-            timezone: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        target: z.ZodOptional<z.ZodString>;
-        to: z.ZodOptional<z.ZodString>;
-        prompt: z.ZodOptional<z.ZodString>;
-        accountId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    replyMode: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-        auto: "auto";
-        static: "static";
-        streaming: "streaming";
-    }>, z.ZodObject<{
-        default: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            static: "static";
-            streaming: "streaming";
-        }>>;
-        group: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            static: "static";
-            streaming: "streaming";
-        }>>;
-        direct: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            static: "static";
-            streaming: "streaming";
-        }>>;
-    }, z.core.$strip>]>>;
-    streaming: z.ZodOptional<z.ZodBoolean>;
-    blockStreaming: z.ZodOptional<z.ZodBoolean>;
-    toolUseDisplay: z.ZodOptional<z.ZodObject<{
-        showFullPaths: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    tools: z.ZodOptional<z.ZodObject<{
-        doc: z.ZodOptional<z.ZodBoolean>;
-        wiki: z.ZodOptional<z.ZodBoolean>;
-        drive: z.ZodOptional<z.ZodBoolean>;
-        perm: z.ZodOptional<z.ZodBoolean>;
-        scopes: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    footer: z.ZodOptional<z.ZodObject<{
-        status: z.ZodOptional<z.ZodBoolean>;
-        elapsed: z.ZodOptional<z.ZodBoolean>;
-        tokens: z.ZodOptional<z.ZodBoolean>;
-        cache: z.ZodOptional<z.ZodBoolean>;
-        context: z.ZodOptional<z.ZodBoolean>;
-        model: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    markdown: z.ZodOptional<z.ZodObject<{
-        tables: z.ZodOptional<z.ZodEnum<{
-            off: "off";
-            bullets: "bullets";
-            code: "code";
-        }>>;
-    }, z.core.$strip>>;
-    configWrites: z.ZodOptional<z.ZodBoolean>;
-    capabilities: z.ZodOptional<z.ZodObject<{
-        image: z.ZodOptional<z.ZodBoolean>;
-        audio: z.ZodOptional<z.ZodBoolean>;
-        video: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    dedup: z.ZodOptional<z.ZodObject<{
-        ttlMs: z.ZodOptional<z.ZodNumber>;
-        maxEntries: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    reactionNotifications: z.ZodOptional<z.ZodEnum<{
-        off: "off";
-        own: "own";
-        all: "all";
-    }>>;
-    threadSession: z.ZodOptional<z.ZodBoolean>;
-    allowBots: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"mentions">]>>;
-    replyInThread: z.ZodOptional<z.ZodBoolean>;
-    uat: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        allowedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        blockedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-}, z.core.$strip>;
-export declare const FeishuConfigSchema: z.ZodObject<{
-    appId: z.ZodOptional<z.ZodString>;
-    appSecret: z.ZodOptional<z.ZodString>;
-    encryptKey: z.ZodOptional<z.ZodString>;
-    verificationToken: z.ZodOptional<z.ZodString>;
-    name: z.ZodOptional<z.ZodString>;
-    enabled: z.ZodOptional<z.ZodBoolean>;
-    domain: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"feishu">, z.ZodLiteral<"lark">, z.ZodString]>>;
-    connectionMode: z.ZodOptional<z.ZodEnum<{
-        websocket: "websocket";
-        webhook: "webhook";
-    }>>;
-    webhookPath: z.ZodOptional<z.ZodString>;
-    webhookPort: z.ZodOptional<z.ZodNumber>;
-    dmPolicy: z.ZodOptional<z.ZodEnum<{
-        open: "open";
-        pairing: "pairing";
-        allowlist: "allowlist";
-        disabled: "disabled";
-    }>>;
-    allowFrom: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
-    groupPolicy: z.ZodOptional<z.ZodEnum<{
-        open: "open";
-        allowlist: "allowlist";
-        disabled: "disabled";
-    }>>;
-    groupAllowFrom: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
-    requireMention: z.ZodOptional<z.ZodBoolean>;
-    respondToMentionAll: z.ZodOptional<z.ZodBoolean>;
-    groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        groupPolicy: z.ZodOptional<z.ZodEnum<{
-            open: "open";
-            allowlist: "allowlist";
-            disabled: "disabled";
-        }>>;
-        requireMention: z.ZodOptional<z.ZodBoolean>;
-        respondToMentionAll: z.ZodOptional<z.ZodBoolean>;
-        tools: z.ZodOptional<z.ZodObject<{
-            allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-        skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        allowFrom: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
-        systemPrompt: z.ZodOptional<z.ZodString>;
-        allowBots: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"mentions">]>>;
-        replyInThread: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>>;
-    historyLimit: z.ZodOptional<z.ZodNumber>;
-    dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
-    dms: z.ZodOptional<z.ZodObject<{
-        historyLimit: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    textChunkLimit: z.ZodOptional<z.ZodNumber>;
-    chunkMode: z.ZodOptional<z.ZodEnum<{
-        newline: "newline";
-        paragraph: "paragraph";
-        none: "none";
-    }>>;
-    blockStreamingCoalesce: z.ZodOptional<z.ZodObject<{
-        minChars: z.ZodOptional<z.ZodNumber>;
-        maxChars: z.ZodOptional<z.ZodNumber>;
-        idleMs: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    mediaMaxMb: z.ZodOptional<z.ZodNumber>;
-    heartbeat: z.ZodOptional<z.ZodObject<{
-        every: z.ZodOptional<z.ZodString>;
-        activeHours: z.ZodOptional<z.ZodObject<{
-            start: z.ZodOptional<z.ZodString>;
-            end: z.ZodOptional<z.ZodString>;
-            timezone: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        target: z.ZodOptional<z.ZodString>;
-        to: z.ZodOptional<z.ZodString>;
-        prompt: z.ZodOptional<z.ZodString>;
-        accountId: z.ZodOptional<z.ZodString>;
-    }, z.core.$strip>>;
-    replyMode: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-        auto: "auto";
-        static: "static";
-        streaming: "streaming";
-    }>, z.ZodObject<{
-        default: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            static: "static";
-            streaming: "streaming";
-        }>>;
-        group: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            static: "static";
-            streaming: "streaming";
-        }>>;
-        direct: z.ZodOptional<z.ZodEnum<{
-            auto: "auto";
-            static: "static";
-            streaming: "streaming";
-        }>>;
-    }, z.core.$strip>]>>;
-    streaming: z.ZodOptional<z.ZodBoolean>;
-    blockStreaming: z.ZodOptional<z.ZodBoolean>;
-    toolUseDisplay: z.ZodOptional<z.ZodObject<{
-        showFullPaths: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    tools: z.ZodOptional<z.ZodObject<{
-        doc: z.ZodOptional<z.ZodBoolean>;
-        wiki: z.ZodOptional<z.ZodBoolean>;
-        drive: z.ZodOptional<z.ZodBoolean>;
-        perm: z.ZodOptional<z.ZodBoolean>;
-        scopes: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    footer: z.ZodOptional<z.ZodObject<{
-        status: z.ZodOptional<z.ZodBoolean>;
-        elapsed: z.ZodOptional<z.ZodBoolean>;
-        tokens: z.ZodOptional<z.ZodBoolean>;
-        cache: z.ZodOptional<z.ZodBoolean>;
-        context: z.ZodOptional<z.ZodBoolean>;
-        model: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    markdown: z.ZodOptional<z.ZodObject<{
-        tables: z.ZodOptional<z.ZodEnum<{
-            off: "off";
-            bullets: "bullets";
-            code: "code";
-        }>>;
-    }, z.core.$strip>>;
-    configWrites: z.ZodOptional<z.ZodBoolean>;
-    capabilities: z.ZodOptional<z.ZodObject<{
-        image: z.ZodOptional<z.ZodBoolean>;
-        audio: z.ZodOptional<z.ZodBoolean>;
-        video: z.ZodOptional<z.ZodBoolean>;
-    }, z.core.$strip>>;
-    dedup: z.ZodOptional<z.ZodObject<{
-        ttlMs: z.ZodOptional<z.ZodNumber>;
-        maxEntries: z.ZodOptional<z.ZodNumber>;
-    }, z.core.$strip>>;
-    reactionNotifications: z.ZodOptional<z.ZodEnum<{
-        off: "off";
-        own: "own";
-        all: "all";
-    }>>;
-    threadSession: z.ZodOptional<z.ZodBoolean>;
-    allowBots: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"mentions">]>>;
-    replyInThread: z.ZodOptional<z.ZodBoolean>;
-    uat: z.ZodOptional<z.ZodObject<{
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        allowedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        blockedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-    }, z.core.$strip>>;
-    accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-        appId: z.ZodOptional<z.ZodString>;
-        appSecret: z.ZodOptional<z.ZodString>;
-        encryptKey: z.ZodOptional<z.ZodString>;
-        verificationToken: z.ZodOptional<z.ZodString>;
-        name: z.ZodOptional<z.ZodString>;
-        enabled: z.ZodOptional<z.ZodBoolean>;
-        domain: z.ZodOptional<z.ZodUnion<readonly [z.ZodLiteral<"feishu">, z.ZodLiteral<"lark">, z.ZodString]>>;
-        connectionMode: z.ZodOptional<z.ZodEnum<{
-            websocket: "websocket";
-            webhook: "webhook";
-        }>>;
-        webhookPath: z.ZodOptional<z.ZodString>;
-        webhookPort: z.ZodOptional<z.ZodNumber>;
-        dmPolicy: z.ZodOptional<z.ZodEnum<{
-            open: "open";
-            pairing: "pairing";
-            allowlist: "allowlist";
-            disabled: "disabled";
-        }>>;
-        allowFrom: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
-        groupPolicy: z.ZodOptional<z.ZodEnum<{
-            open: "open";
-            allowlist: "allowlist";
-            disabled: "disabled";
-        }>>;
-        groupAllowFrom: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
-        requireMention: z.ZodOptional<z.ZodBoolean>;
-        respondToMentionAll: z.ZodOptional<z.ZodBoolean>;
-        groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
-            groupPolicy: z.ZodOptional<z.ZodEnum<{
-                open: "open";
-                allowlist: "allowlist";
-                disabled: "disabled";
-            }>>;
-            requireMention: z.ZodOptional<z.ZodBoolean>;
-            respondToMentionAll: z.ZodOptional<z.ZodBoolean>;
-            tools: z.ZodOptional<z.ZodObject<{
-                allow: z.ZodOptional<z.ZodArray<z.ZodString>>;
-                deny: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            }, z.core.$strip>>;
-            skills: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            enabled: z.ZodOptional<z.ZodBoolean>;
-            allowFrom: z.ZodPipe<z.ZodOptional<z.ZodUnion<readonly [z.ZodString, z.ZodArray<z.ZodString>]>>, z.ZodTransform<string[] | undefined, string | string[] | undefined>>;
-            systemPrompt: z.ZodOptional<z.ZodString>;
-            allowBots: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"mentions">]>>;
-            replyInThread: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>>;
-        historyLimit: z.ZodOptional<z.ZodNumber>;
-        dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
-        dms: z.ZodOptional<z.ZodObject<{
-            historyLimit: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        textChunkLimit: z.ZodOptional<z.ZodNumber>;
-        chunkMode: z.ZodOptional<z.ZodEnum<{
-            newline: "newline";
-            paragraph: "paragraph";
-            none: "none";
-        }>>;
-        blockStreamingCoalesce: z.ZodOptional<z.ZodObject<{
-            minChars: z.ZodOptional<z.ZodNumber>;
-            maxChars: z.ZodOptional<z.ZodNumber>;
-            idleMs: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        mediaMaxMb: z.ZodOptional<z.ZodNumber>;
-        heartbeat: z.ZodOptional<z.ZodObject<{
-            every: z.ZodOptional<z.ZodString>;
-            activeHours: z.ZodOptional<z.ZodObject<{
-                start: z.ZodOptional<z.ZodString>;
-                end: z.ZodOptional<z.ZodString>;
-                timezone: z.ZodOptional<z.ZodString>;
-            }, z.core.$strip>>;
-            target: z.ZodOptional<z.ZodString>;
-            to: z.ZodOptional<z.ZodString>;
-            prompt: z.ZodOptional<z.ZodString>;
-            accountId: z.ZodOptional<z.ZodString>;
-        }, z.core.$strip>>;
-        replyMode: z.ZodOptional<z.ZodUnion<readonly [z.ZodEnum<{
-            auto: "auto";
-            static: "static";
-            streaming: "streaming";
-        }>, z.ZodObject<{
-            default: z.ZodOptional<z.ZodEnum<{
-                auto: "auto";
-                static: "static";
-                streaming: "streaming";
-            }>>;
-            group: z.ZodOptional<z.ZodEnum<{
-                auto: "auto";
-                static: "static";
-                streaming: "streaming";
-            }>>;
-            direct: z.ZodOptional<z.ZodEnum<{
-                auto: "auto";
-                static: "static";
-                streaming: "streaming";
-            }>>;
-        }, z.core.$strip>]>>;
-        streaming: z.ZodOptional<z.ZodBoolean>;
-        blockStreaming: z.ZodOptional<z.ZodBoolean>;
-        toolUseDisplay: z.ZodOptional<z.ZodObject<{
-            showFullPaths: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        tools: z.ZodOptional<z.ZodObject<{
-            doc: z.ZodOptional<z.ZodBoolean>;
-            wiki: z.ZodOptional<z.ZodBoolean>;
-            drive: z.ZodOptional<z.ZodBoolean>;
-            perm: z.ZodOptional<z.ZodBoolean>;
-            scopes: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        footer: z.ZodOptional<z.ZodObject<{
-            status: z.ZodOptional<z.ZodBoolean>;
-            elapsed: z.ZodOptional<z.ZodBoolean>;
-            tokens: z.ZodOptional<z.ZodBoolean>;
-            cache: z.ZodOptional<z.ZodBoolean>;
-            context: z.ZodOptional<z.ZodBoolean>;
-            model: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        markdown: z.ZodOptional<z.ZodObject<{
-            tables: z.ZodOptional<z.ZodEnum<{
-                off: "off";
-                bullets: "bullets";
-                code: "code";
-            }>>;
-        }, z.core.$strip>>;
-        configWrites: z.ZodOptional<z.ZodBoolean>;
-        capabilities: z.ZodOptional<z.ZodObject<{
-            image: z.ZodOptional<z.ZodBoolean>;
-            audio: z.ZodOptional<z.ZodBoolean>;
-            video: z.ZodOptional<z.ZodBoolean>;
-        }, z.core.$strip>>;
-        dedup: z.ZodOptional<z.ZodObject<{
-            ttlMs: z.ZodOptional<z.ZodNumber>;
-            maxEntries: z.ZodOptional<z.ZodNumber>;
-        }, z.core.$strip>>;
-        reactionNotifications: z.ZodOptional<z.ZodEnum<{
-            off: "off";
-            own: "own";
-            all: "all";
-        }>>;
-        threadSession: z.ZodOptional<z.ZodBoolean>;
-        allowBots: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"mentions">]>>;
-        replyInThread: z.ZodOptional<z.ZodBoolean>;
-        uat: z.ZodOptional<z.ZodObject<{
-            enabled: z.ZodOptional<z.ZodBoolean>;
-            allowedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-            blockedScopes: z.ZodOptional<z.ZodArray<z.ZodString>>;
-        }, z.core.$strip>>;
-    }, z.core.$strip>>>;
-}, z.core.$strip>;
+export declare const UATConfigSchema: any;
+export declare const FeishuGroupSchema: any;
+export declare const FeishuAccountConfigSchema: any;
+export declare const FeishuConfigSchema: any;
 /**
  * JSON Schema derived from FeishuConfigSchema.
  *

package/src/messaging/converters/post.js

@@ -10,10 +10,30 @@
  */
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.convertPost = void 0;
+const lark_logger_1 = require("../../core/lark-logger.js");
 const content_converter_helpers_1 = require("./content-converter-helpers.js");
 const utils_1 = require("./utils.js");
+const log = (0, lark_logger_1.larkLogger)('converters/post');
 /** Preferred locale order for multi-language post unwrapping. */
 const LOCALE_PRIORITY = ['zh_cn', 'en_us', 'ja_jp'];
+/**
+ * Scan token for native markdown: a code region to SKIP, OR an image to intercept.
+ * Group 1 (code region) matches first so `![alt](key)` inside code is consumed
+ * verbatim and never intercepted:
+ *   - fenced block: ```...``` or ~~~...~~~ (multi-line, lazy)
+ *   - inline span:  ``...`` or `...` (single-line)
+ * Group 2 (alt) + Group 3 (target) are the image when no code region matched.
+ */
+const MD_SCAN_RE = /(```[\s\S]*?```|~~~[\s\S]*?~~~|``[\s\S]*?``|`[^`\n]*`)|!\[([^\]]*)\]\(([^)]+)\)/g;
+/** Feishu image_key prefix (aligned with markdown-style.ts stripInvalidImageKeys & case 'img'). */
+const FEISHU_IMAGE_KEY_RE = /^img_/;
+/**
+ * Inbound native-markdown size ceiling (chars). Guards against pathological
+ * posts (huge tables / deep nesting) blowing up memory/token before the
+ * downstream chunker runs. One order above the outbound chunk magnitude
+ * (outbound default 15000). Tunable; per-account config override is a follow-up.
+ */
+const MAX_INBOUND_MD_LEN = 100_000;
 /**
  * Unwrap a parsed post object that may be locale-wrapped.
  *
@@ -22,7 +42,7 @@ const LOCALE_PRIORITY = ['zh_cn', 'en_us', 'ja_jp'];
  *   - Locale: `{ zh_cn: { title, content }, en_us: { title, content } }`
  */
 function unwrapLocale(parsed) {
-    if ('title' in parsed || 'content' in parsed) {
+    if ('title' in parsed || 'content' in parsed || 'content_v2' in parsed) {
         return parsed;
     }
     for (const locale of LOCALE_PRIORITY) {
@@ -51,26 +71,36 @@ const convertPost = (raw, ctx) => {
     }
     const resources = [];
     const lines = [];
+    const seenFileKeys = new Set();
     // Title
     if (parsed.title) {
         lines.push(`**${parsed.title}**`, '');
     }
-    const contentBlocks = parsed.content ?? [];
+    const v2 = parsed.content_v2;
+    const usedV2 = Array.isArray(v2) && v2.length > 0;
+    const contentBlocks = usedV2 ? v2 : (parsed.content ?? []);
+    log.info('post content source selected', {
+        messageId: ctx.messageId,
+        source: usedV2 ? 'content_v2' : 'content',
+        hasV2: Array.isArray(v2),
+        v2Len: Array.isArray(v2) ? v2.length : 0,
+    });
     for (const paragraph of contentBlocks) {
         if (!Array.isArray(paragraph))
             continue;
         let line = '';
         for (const el of paragraph) {
-            line += renderElement(el, ctx, resources);
+            line += renderElement(el, ctx, resources, seenFileKeys);
         }
         lines.push(line);
     }
     let content = lines.join('\n').trim() || '[rich text message]';
     content = (0, content_converter_helpers_1.resolveMentions)(content, ctx);
+    content = capInboundLength(content, resources);
     return { content, resources };
 };
 exports.convertPost = convertPost;
-function renderElement(el, ctx, resources) {
+function renderElement(el, ctx, resources, seenFileKeys) {
     switch (el.tag) {
         case 'text': {
             let text = el.text ?? '';
@@ -110,6 +140,9 @@ function renderElement(el, ctx, resources) {
             }
             return '';
         }
+        case 'md': {
+            return renderInlineImages(el.text ?? '', resources, seenFileKeys);
+        }
         case 'code_block': {
             const lang = el.language ?? '';
             const code = el.text ?? '';
@@ -137,3 +170,66 @@ function applyStyle(text, style) {
         result = `\`${result}\``;
     return result;
 }
+/**
+ * Scan native markdown for `![alt](target)` and intercept feishu image_keys.
+ * - target matches `^img_` → register a downloadable resource (Set-deduped) and
+ *   normalize the FIRST occurrence to `![image](key)` (the only form
+ *   substituteMediaPaths can replace); later occurrences of the same key collapse
+ *   to sanitized alt text so no bare key / un-replaceable marker leaks downstream.
+ * - everything else (https/http, data:, protocol-relative, relative/anchor) is kept
+ *   verbatim and never downloaded.
+ * Image syntax inside a code region (fenced block or inline span) is left verbatim
+ * and never intercepted — code is shown as-is, not rendered.
+ */
+function renderInlineImages(md, resources, seen) {
+    return md.replace(MD_SCAN_RE, (whole, codeRegion, alt, target) => {
+        if (codeRegion !== undefined) {
+            return whole; // fenced block / inline code → keep verbatim, never intercept
+        }
+        if (!FEISHU_IMAGE_KEY_RE.test(target)) {
+            return whole;
+        }
+        if (!seen.has(target)) {
+            seen.add(target);
+            resources.push({ type: 'image', fileKey: target });
+            return `![image](${target})`;
+        }
+        return sanitizeAlt(alt);
+    });
+}
+/** Strip nested image syntax and bare feishu keys from alt so it cannot be
+ *  re-matched by substituteMediaPaths nor inject UGC markers. */
+function sanitizeAlt(alt) {
+    return alt
+        .replace(/!\[[^\]]*\]\([^)]*\)/g, '')
+        .replace(/img_[A-Za-z0-9_-]+/g, '')
+        .trim();
+}
+/**
+ * Cap inbound text length at a safe boundary (never split an `![image](key)`
+ * marker), tag `[truncated]`, and drop image resources whose marker fell off the
+ * end so we never register an orphan download with no in-text marker.
+ */
+function capInboundLength(content, resources) {
+    if (content.length <= MAX_INBOUND_MD_LEN)
+        return content;
+    let cut = content.lastIndexOf('\n', MAX_INBOUND_MD_LEN);
+    if (cut <= 0) {
+        // Single huge line: back off so we never cut inside an image marker.
+        cut = MAX_INBOUND_MD_LEN;
+        const markerStart = content.lastIndexOf('![image](', cut);
+        if (markerStart !== -1) {
+            const markerEnd = content.indexOf(')', markerStart);
+            if (markerEnd === -1 || markerEnd >= cut)
+                cut = markerStart;
+        }
+    }
+    const truncated = `${content.slice(0, cut).replace(/\s+$/, '')}\n[truncated]`;
+    for (let i = resources.length - 1; i >= 0; i--) {
+        const r = resources[i];
+        if (r.type === 'image' && !truncated.includes(`![image](${r.fileKey})`)) {
+            resources.splice(i, 1);
+        }
+    }
+    return truncated;
+}

package/src/messaging/outbound/deliver.js

@@ -32,8 +32,9 @@ function buildPostContent(text) {
 }
 /**
  * Pre-processes text before Feishu delivery. Runs the full mention
- * normalizer (tag rewrite + plain `@Name` resolution + `@all` aliases),
- * markdown-table conversion, and Markdown style optimization.
+ * normalizer (tag rewrite + plain `@Name` resolution + `@all` aliases)
+ * and Markdown style optimization. Markdown tables/code blocks are left
+ * as-is so Feishu renders them natively in the post(`tag:md`).
  *
  * Falls back to the raw text on any normalizer failure so a parser bug
  * never blocks send. Sentinels collected during normalization are
@@ -60,22 +61,6 @@ async function prepareTextForLark(cfg, text, to, accountId) {
             log.warn(`normalizeOutboundMentions failed in prepareTextForLark, using raw text: ${String(err)}`);
         }
     }
-    // Convert markdown tables to Feishu-compatible format using per-account
-    // tableMode setting.
-    try {
-        const accountScopedCfg = (0, accounts_1.createAccountScopedConfig)(cfg, accountId);
-        const runtime = lark_client_1.LarkClient.runtime;
-        if (runtime?.channel?.text?.convertMarkdownTables && runtime.channel.text.resolveMarkdownTableMode) {
-            const tableMode = runtime.channel.text.resolveMarkdownTableMode({
-                cfg: accountScopedCfg,
-                channel: 'feishu',
-            });
-            processed = runtime.channel.text.convertMarkdownTables(processed, tableMode);
-        }
-    }
-    catch {
-        // Runtime not available -- use the text as-is.
-    }
     return {
         text: (0, markdown_style_1.optimizeMarkdownStyle)(processed, 1),
         sentinels,

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

@@ -57,8 +57,8 @@ export interface SendFeishuCardParams {
  * sent as a threaded reply; otherwise it is sent as a new message using
  * the appropriate `receive_id_type`.
  *
- * Markdown tables in the text are automatically converted to the format
- * supported by Feishu via the runtime's table converter when available.
+ * 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.

package/src/messaging/outbound/send.js

@@ -74,32 +74,6 @@ function recordFeishuSendSentinels(resolvedAccountId, to, threadId, sentinels) {
 // ---------------------------------------------------------------------------
 // sendMessageFeishu
 // ---------------------------------------------------------------------------
-/**
- * Resolve the configured markdown table mode for Feishu and convert tables if
- * the runtime converter is available.
- *
- * @param cfg - Plugin configuration
- * @param text - Raw markdown text
- * @param accountId - Optional account identifier for multi-account setups
- * @returns Converted text, or the original text when runtime helpers are unavailable
- */
-function convertMarkdownTablesForFeishu(cfg, text, accountId) {
-    try {
-        const accountScopedCfg = (0, accounts_1.createAccountScopedConfig)(cfg, accountId);
-        const runtime = lark_client_1.LarkClient.runtime;
-        if (runtime?.channel?.text?.convertMarkdownTables && runtime.channel.text.resolveMarkdownTableMode) {
-            const tableMode = runtime.channel.text.resolveMarkdownTableMode({
-                cfg: accountScopedCfg,
-                channel: 'feishu',
-            });
-            return runtime.channel.text.convertMarkdownTables(text, tableMode);
-        }
-    }
-    catch {
-        // Runtime not available -- use the text as-is.
-    }
-    return text;
-}
 /**
  * Send a text message (rendered as a Feishu "post" with markdown support)
  * to a chat or user.
@@ -109,8 +83,8 @@ function convertMarkdownTablesForFeishu(cfg, text, accountId) {
  * sent as a threaded reply; otherwise it is sent as a new message using
  * the appropriate `receive_id_type`.
  *
- * Markdown tables in the text are automatically converted to the format
- * supported by Feishu via the runtime's table converter when available.
+ * 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.
@@ -141,8 +115,6 @@ async function sendMessageFeishu(params) {
             if (mentions && mentions.length > 0) {
                 processed = (0, mention_1.buildMentionedMessage)(mentions, processed);
             }
-            // Convert markdown tables to Feishu-compatible format.
-            processed = convertMarkdownTablesForFeishu(cfg, processed, accountId);
             // Apply Markdown style optimization.
             processed = (0, markdown_style_1.optimizeMarkdownStyle)(processed, 1);
             postBody[locale] = {
@@ -158,8 +130,6 @@ async function sendMessageFeishu(params) {
         if (mentions && mentions.length > 0) {
             messageText = (0, mention_1.buildMentionedMessage)(mentions, messageText);
         }
-        // Convert markdown tables to Feishu-compatible format.
-        messageText = convertMarkdownTablesForFeishu(cfg, messageText, accountId);
         // Apply Markdown style optimization.
         messageText = (0, markdown_style_1.optimizeMarkdownStyle)(messageText, 1);
         contentPayload = JSON.stringify({
@@ -424,9 +394,8 @@ async function sendMarkdownCardFeishu(params) {
 async function editMessageFeishu(params) {
     const { cfg, messageId, text, accountId } = params;
     const client = lark_client_1.LarkClient.fromCfg(cfg, accountId).sdk;
-    const convertedText = convertMarkdownTablesForFeishu(cfg, text, accountId);
     // Use cardVersion=1 consistent with sendMessageFeishu post path.
-    const optimizedText = (0, markdown_style_1.optimizeMarkdownStyle)(convertedText, 1);
+    const optimizedText = (0, markdown_style_1.optimizeMarkdownStyle)(text, 1);
     const contentPayload = JSON.stringify({
         zh_cn: {
             content: [[{ tag: 'md', text: optimizedText }]],

package/src/tools/ask-user-question.js

@@ -146,6 +146,9 @@ function getInputFieldName(questionIndex) {
 function getSelectFieldName(questionIndex) {
     return `${SELECT_FIELD_NAME}_${questionIndex}`;
 }
+function getCheckerFieldName(questionIndex, optionIndex) {
+    return `${SELECT_FIELD_NAME}_${questionIndex}_${optionIndex}`;
+}
 // ---------------------------------------------------------------------------
 // Card Action Handler (used by event-handlers.ts)
 // ---------------------------------------------------------------------------
@@ -187,12 +190,13 @@ function handleAskUserAction(data, _cfg, accountId) {
                 operationId = actionName.slice(SUBMIT_BUTTON_PREFIX.length);
             }
         }
-        // Detect form submit by tag + formValue
-        if (!action && actionTag === 'button' && formValue) {
+        // Detect ask-user form submit by tag + formValue. Business plugins also use
+        // Feishu forms, so only consume buttons generated by this tool.
+        if (!action && actionTag === 'button' && formValue && actionName?.startsWith(SUBMIT_BUTTON_PREFIX)) {
             action = ACTION_SUBMIT;
         }
-        // Some SDK versions emit tag='form_submit'
-        if (!action && actionTag === 'form_submit') {
+        // Some SDK versions emit tag='form_submit' without button value/name.
+        if (!action && actionTag === 'form_submit' && (!actionName || actionName.startsWith(SUBMIT_BUTTON_PREFIX))) {
             action = ACTION_SUBMIT;
             if (!formValue && event.action) {
                 formValue = event.action;
@@ -244,8 +248,11 @@ function handleAskUserAction(data, _cfg, accountId) {
             answer = readFormTextField(formValue, getInputFieldName(i));
         }
         else if (q.multiSelect) {
-            // Multi-select
-            const selected = readFormMultiSelect(formValue, getSelectFieldName(i));
+            // Multi-select — either a dropdown (multi_select_static) or a set of
+            // independent checker rows, depending on selectStyle.
+            const selected = q.selectStyle === 'checkbox'
+                ? readFormCheckers(formValue, i, q.options)
+                : readFormMultiSelect(formValue, getSelectFieldName(i));
             if (selected.length > 0) {
                 answer = selected.join(', ');
             }
@@ -434,6 +441,22 @@ function readFormMultiSelect(formValue, fieldName) {
     }
     return [];
 }
+/**
+ * Read the selected labels from a set of independent checker (checkbox)
+ * components — used when a multi-select question uses selectStyle 'checkbox'.
+ * Each option has its own boolean field (see getCheckerFieldName); Feishu may
+ * report the checked state as a boolean or a string.
+ */
+function readFormCheckers(formValue, questionIndex, options) {
+    const selected = [];
+    for (let optIndex = 0; optIndex < options.length; optIndex++) {
+        const raw = formValue[getCheckerFieldName(questionIndex, optIndex)];
+        if (raw === true || raw === 'true') {
+            selected.push(options[optIndex].label);
+        }
+    }
+    return selected;
+}
 // ---------------------------------------------------------------------------
 // Card Builders — unified form layout
 // ---------------------------------------------------------------------------
@@ -495,7 +518,24 @@ function buildQuestionFormElements(q, questionIndex) {
         text: { tag: 'plain_text', content: opt.label },
         value: opt.label,
     }));
-    if (q.multiSelect) {
+    if (q.multiSelect && q.selectStyle === 'checkbox') {
+        // ---- Multi-select as independent checkbox rows ----
+        // Each option is its own checker so the user sees every selection at a
+        // glance before submitting (vs. the compact dropdown collapsed state).
+        // Note: checker requires a `value` field to pass Feishu's client-side
+        // interactive-component validation (otherwise code 200340).
+        elems.push(labelMd);
+        q.options.forEach((opt, optIndex) => {
+            elems.push({
+                tag: 'checker',
+                name: getCheckerFieldName(questionIndex, optIndex),
+                checked: false,
+                text: { tag: 'plain_text', content: opt.label },
+                value: { option: opt.label },
+            });
+        });
+    }
+    else if (q.multiSelect) {
         // ---- Multi-select dropdown ----
         elems.push(buildLabeledRow(labelMd, {
             tag: 'multi_select_static',
@@ -778,6 +818,9 @@ const AskUserQuestionSchema = typebox_1.Type.Object({
         multiSelect: typebox_1.Type.Boolean({
             description: 'Whether multiple options can be selected (ignored when options is empty)',
         }),
+        selectStyle: typebox_1.Type.Optional(typebox_1.Type.Union([typebox_1.Type.Literal('dropdown'), typebox_1.Type.Literal('checkbox')], {
+            description: 'For multi-select questions only: "dropdown" (default, compact multi-select dropdown) or "checkbox" (each option shown as a separate checkbox row, so the user can see all selected options at a glance before submitting). Ignored for single-select and free-text questions.',
+        })),
     }), {
         description: 'Questions to ask the user (1-6 questions)',
         minItems: 1,

package/src/tools/oapi/im/message.js

@@ -16,132 +16,7 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.registerFeishuImUserMessageTool = registerFeishuImUserMessageTool;
 const typebox_1 = require("@sinclair/typebox");
-const accounts_1 = require("../../../core/accounts.js");
-const lark_client_1 = require("../../../core/lark-client.js");
 const helpers_1 = require("../helpers.js");
-const FEISHU_POST_LOCALE_PRIORITY = ['zh_cn', 'en_us', 'ja_jp'];
-/**
- * Check whether a value is a non-null object whose properties can be read.
- *
- * @param value - The value to check
- * @returns Whether the value is a non-null object
- */
-function isRecord(value) {
-    return value != null && typeof value === 'object';
-}
-/**
- * Collect post content bodies from a parsed Feishu post payload.
- * Handles both flat (title/content at root) and multi-locale wrapper structures.
- *
- * @param parsed - The parsed JSON object
- * @returns List of post content bodies to process
- */
-function collectPostContents(parsed) {
-    if ('title' in parsed || 'content' in parsed) {
-        return [parsed];
-    }
-    const bodies = [];
-    const seen = new Set();
-    // Process well-known locales first
-    for (const locale of FEISHU_POST_LOCALE_PRIORITY) {
-        const localeContent = parsed[locale];
-        if (!isRecord(localeContent)) {
-            continue;
-        }
-        const body = localeContent;
-        if (!seen.has(body)) {
-            bodies.push(body);
-            seen.add(body);
-        }
-    }
-    // Process remaining locales
-    for (const value of Object.values(parsed)) {
-        if (!isRecord(value)) {
-            continue;
-        }
-        const body = value;
-        if (!seen.has(body)) {
-            bodies.push(body);
-            seen.add(body);
-        }
-    }
-    return bodies;
-}
-/**
- * Convert markdown tables to the Feishu-compatible list format.
- *
- * Reuses the channel runtime's existing converter so the tool send path
- * behaves identically to the main reply path.
- *
- * @param cfg - Current tool configuration
- * @param text - Raw markdown text
- * @returns Converted text, or the original text when runtime is unavailable
- */
-function convertMarkdownTablesForLark(cfg, text) {
-    try {
-        const runtime = lark_client_1.LarkClient.runtime;
-        if (runtime?.channel?.text?.convertMarkdownTables && runtime.channel.text.resolveMarkdownTableMode) {
-            const tableMode = runtime.channel.text.resolveMarkdownTableMode({
-                cfg,
-                channel: 'feishu',
-            });
-            return runtime.channel.text.convertMarkdownTables(text, tableMode);
-        }
-    }
-    catch {
-        // Runtime converter unavailable -- keep text as-is.
-    }
-    return text;
-}
-/**
- * Pre-process `tag="md"` text nodes inside `post` messages so the tool send
- * path also renders markdown tables correctly.
- *
- * @param cfg - Current tool configuration
- * @param msgType - Feishu message type
- * @param content - The JSON string from tool parameters
- * @returns Pre-processed JSON string
- */
-function preprocessPostContent(cfg, msgType, content) {
-    if (msgType !== 'post') {
-        return content;
-    }
-    try {
-        const parsed = JSON.parse(content);
-        if (!isRecord(parsed)) {
-            return content;
-        }
-        const postContents = collectPostContents(parsed);
-        if (postContents.length === 0) {
-            return content;
-        }
-        let changed = false;
-        for (const postContent of postContents) {
-            if (!postContent.content || !Array.isArray(postContent.content)) {
-                continue;
-            }
-            for (const line of postContent.content) {
-                if (!Array.isArray(line)) {
-                    continue;
-                }
-                for (const block of line) {
-                    if (!isRecord(block) || block.tag !== 'md' || typeof block.text !== 'string') {
-                        continue;
-                    }
-                    const convertedText = convertMarkdownTablesForLark(cfg, block.text);
-                    if (convertedText !== block.text) {
-                        block.text = convertedText;
-                        changed = true;
-                    }
-                }
-            }
-        }
-        return changed ? JSON.stringify(parsed) : content;
-    }
-    catch {
-        return content;
-    }
-}
 // ---------------------------------------------------------------------------
 // Schema
 // ---------------------------------------------------------------------------
@@ -220,14 +95,12 @@ function registerFeishuImUserMessageTool(api) {
                     // -----------------------------------------------------------------
                     case 'send': {
                         log.info(`send: receive_id_type=${p.receive_id_type}, receive_id=${p.receive_id}, msg_type=${p.msg_type}`);
-                        const accountScopedCfg = (0, accounts_1.createAccountScopedConfig)(cfg, client.account.accountId);
-                        const processedContent = preprocessPostContent(accountScopedCfg, p.msg_type, p.content);
                         const res = await client.invoke('feishu_im_user_message.send', (sdk, opts) => sdk.im.v1.message.create({
                             params: { receive_id_type: p.receive_id_type },
                             data: {
                                 receive_id: p.receive_id,
                                 msg_type: p.msg_type,
-                                content: processedContent,
+                                content: p.content,
                                 uuid: p.uuid,
                             },
                         }, opts), {
@@ -248,12 +121,10 @@ function registerFeishuImUserMessageTool(api) {
                     // -----------------------------------------------------------------
                     case 'reply': {
                         log.info(`reply: message_id=${p.message_id}, msg_type=${p.msg_type}, reply_in_thread=${p.reply_in_thread ?? false}`);
-                        const accountScopedCfg = (0, accounts_1.createAccountScopedConfig)(cfg, client.account.accountId);
-                        const processedContent = preprocessPostContent(accountScopedCfg, p.msg_type, p.content);
                         const res = await client.invoke('feishu_im_user_message.reply', (sdk, opts) => sdk.im.v1.message.reply({
                             path: { message_id: p.message_id },
                             data: {
-                                content: processedContent,
+                                content: p.content,
                                 msg_type: p.msg_type,
                                 reply_in_thread: p.reply_in_thread,
                                 uuid: p.uuid,

package/tsdown.config.d.ts

@@ -1,2 +1,2 @@
-declare const _default: import("tsdown/types-D2Jnze_i").d;
+declare const _default: any;
 export default _default;

package/vitest.config.d.ts

@@ -1,2 +1,2 @@
-declare const _default: UserConfig;
+declare const _default: any;
 export default _default;