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

package/package.json

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

package/src/channel/event-handlers.js

@@ -9,6 +9,39 @@
  * function size. Each handler receives a MonitorContext with all
  * dependencies needed to process the event.
  */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleMessageEvent = handleMessageEvent;
 exports.handleReactionEvent = handleReactionEvent;
@@ -16,6 +49,7 @@ exports.handleBotMembershipEvent = handleBotMembershipEvent;
 exports.handleVcMeetingInvitedEvent = handleVcMeetingInvitedEvent;
 exports.handleCommentEvent = handleCommentEvent;
 exports.handleCardActionEvent = handleCardActionEvent;
+const crypto = __importStar(require("node:crypto"));
 const handler_1 = require("../messaging/inbound/handler.js");
 const reaction_handler_1 = require("../messaging/inbound/reaction-handler.js");
 const comment_handler_1 = require("../messaging/inbound/comment-handler.js");
@@ -27,6 +61,9 @@ const lark_ticket_1 = require("../core/lark-ticket.js");
 const lark_logger_1 = require("../core/lark-logger.js");
 const auto_auth_1 = require("../tools/auto-auth.js");
 const ask_user_question_1 = require("../tools/ask-user-question.js");
+const synthetic_message_1 = require("../messaging/inbound/synthetic-message.js");
+const chat_info_cache_1 = require("../core/chat-info-cache.js");
+const message_lookup_1 = require("../messaging/shared/message-lookup.js");
 const chat_queue_1 = require("./chat-queue.js");
 const abort_detect_1 = require("./abort-detect.js");
 const interactive_dispatch_1 = require("./interactive-dispatch.js");
@@ -358,11 +395,107 @@ async function handleCommentEvent(ctx, data) {
         error(`feishu[${accountId}]: error handling comment event: ${String(err)}`);
     }
 }
-// ---------------------------------------------------------------------------
-// Card action handler
-// ---------------------------------------------------------------------------
+/**
+ * Generic "button click = inject a user message" mechanism.
+ *
+ * When a card button's `value` is `{ action: "inject_prompt", prompt: "<text>" }`,
+ * clicking it dispatches `<text>` as a synthetic user message (via the standard
+ * inbound pipeline, `replyToMessageId` set to the card's own message so the agent
+ * replies in the same conversation) and returns a toast receipt. This lets any
+ * card offer functional buttons — click a button, the corresponding request runs,
+ * no typing needed — without registering a business plugin handler.
+ *
+ * Returns the toast receipt when the event is an inject_prompt action, or
+ * `undefined` so the caller falls through to the other card handlers.
+ *
+ * Security / correctness (mirrors reaction-handler, which faces the same
+ * "card-ish event carries no chat_type/thread_id" problem):
+ *  - Chat type is resolved from the cached chat-info helper and the dispatch
+ *    fails closed if it can't be determined, so a group card is never
+ *    mis-routed as a p2p direct session.
+ *  - The synthetic message goes through the real access-control gate
+ *    (`cardActionGate`): the click satisfies the mention requirement, but
+ *    group/DM admission and sender allowlists are still enforced.
+ *  - The synthetic message id is unique per click (event_id / token / uuid), so
+ *    inbound MessageSid dedup does not silently drop a second button click.
+ *  - Only a real `operator.open_id` is used as the sender identity; a Schema-2
+ *    `user_id` is never smuggled into an `open_id` field (fail closed instead).
+ *
+ * Note: `card.action.trigger` is a synchronous request/response — the handler
+ * MUST return a card receipt (here a toast). Returning `undefined` makes the SDK
+ * fall back to a card update it cannot resolve, which Feishu rejects with
+ * `99992354 Invalid ids:[card]`. So we dispatch the synthetic message
+ * asynchronously (`setImmediate`) and return the toast synchronously.
+ */
+function handleInjectPromptAction(ctx, data) {
+    const ev = data;
+    const val = ev.action?.value;
+    if (!val || val.action !== 'inject_prompt' || typeof val.prompt !== 'string' || !val.prompt.trim()) {
+        return undefined;
+    }
+    // Use only a real open_id as the sender identity. A Schema-2 callback may carry
+    // only operator.user_id; that is a different namespace and must not be written
+    // into an open_id field (would corrupt session routing, sender allowlists,
+    // user-token lookup, and owner checks). Fail closed until user_id→open_id
+    // conversion is supported.
+    const senderOpenId = ev.operator?.open_id?.trim();
+    const chatId = ev.open_chat_id ?? ev.context?.open_chat_id;
+    const cardMsgId = ev.open_message_id ?? ev.context?.open_message_id;
+    if (!senderOpenId || !chatId) {
+        elog.warn('inject_prompt: missing operator open_id or chatId, ignoring');
+        return { toast: { type: 'error', content: '无法处理该操作' } };
+    }
+    const prompt = val.prompt;
+    // Unique per click so inbound dedup (by MessageSid, ~20min) does not drop a
+    // second click on a different button of the same card. Prefer the callback's
+    // unique event_id; fall back to token, then a random uuid.
+    const syntheticMessageId = ev.event_id?.trim() || ev.token?.trim() || crypto.randomUUID();
+    // Dispatch asynchronously so the synchronous toast receipt is not blocked.
+    // The card trigger carries no chat_type or thread_id, so resolve both here.
+    setImmediate(async () => {
+        try {
+            // Resolve the real chat type; fail closed if it can't be determined
+            // (do NOT assume p2p — that would mis-route a group card).
+            const info = await (0, chat_info_cache_1.getChatInfo)({ cfg: ctx.cfg, chatId, accountId: ctx.accountId });
+            if (!info) {
+                elog.warn(`inject_prompt: could not resolve chat type for ${chatId}, skipping dispatch`);
+                return;
+            }
+            const chatType = info.chatMode === 'group' || info.chatMode === 'topic' ? 'group' : 'p2p';
+            // Recover the thread id from the card's own message (the trigger has none)
+            // so thread session isolation is preserved.
+            let threadId;
+            if (cardMsgId) {
+                const msg = await (0, message_lookup_1.getMessageFeishu)({ cfg: ctx.cfg, messageId: cardMsgId, accountId: ctx.accountId }).catch(() => null);
+                threadId = msg?.threadId;
+            }
+            await (0, synthetic_message_1.dispatchSyntheticTextMessage)({
+                cfg: ctx.cfg,
+                accountId: ctx.accountId,
+                chatId,
+                senderOpenId,
+                text: prompt,
+                syntheticMessageId,
+                replyToMessageId: cardMsgId ?? '',
+                chatType,
+                threadId,
+                forceMention: false,
+                cardActionGate: true,
+                runtime: ctx.runtime,
+            });
+        }
+        catch (e) {
+            elog.warn(`inject_prompt dispatch failed: ${e}`);
+        }
+    });
+    return { toast: { type: 'info', content: '收到，正在为你处理…' } };
+}
 async function handleCardActionEvent(ctx, data) {
     try {
+        // inject_prompt：通用「按钮点击 = 注入一条用户消息」机制（渠道内建，优先拦截）。
+        const injectResult = handleInjectPromptAction(ctx, data);
+        if (injectResult !== undefined)
+            return injectResult;
         // AskUserQuestion：表单卡片交互（宿主内建能力优先）
         const askResult = (0, ask_user_question_1.handleAskUserAction)(data, ctx.cfg, ctx.accountId);
         if (askResult !== undefined)

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 ?? ev.action?.name;
+        const action = ev.action?.value?.action ?? ev.action?.name ?? formSubmitActionName(ev);
         if (!action || typeof action !== 'string')
             return null;
         const openChatId = ev.open_chat_id ?? ev.context?.open_chat_id;
@@ -39,6 +39,12 @@ function extractBasics(data) {
         return null;
     }
 }
+function formSubmitActionName(ev) {
+    const tag = ev.action?.tag;
+    if (tag !== 'form_submit')
+        return undefined;
+    return ev.action?.form_name;
+}
 function buildMarkdownCard(text) {
     return {
         schema: '2.0',

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

@@ -9,10 +9,477 @@
  */
 import { z } from 'zod';
 export { z };
-export declare const UATConfigSchema: any;
-export declare const FeishuGroupSchema: any;
-export declare const FeishuAccountConfigSchema: any;
-export declare const FeishuConfigSchema: any;
+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>;
 /**
  * JSON Schema derived from FeishuConfigSchema.
  *

package/src/messaging/inbound/gate.d.ts

@@ -88,4 +88,11 @@ export declare function checkMessageGate(params: {
     /** account 级别的 ClawdbotConfig（channels.feishu 已替换为 per-account 合并后的配置） */
     accountScopedCfg?: ClawdbotConfig;
     log: (...args: unknown[]) => void;
+    /**
+     * When true, treat the mention requirement as already satisfied (e.g. a card
+     * click is itself an explicit user action targeting the bot). Group/DM
+     * admission and sender-allowlist checks still run — this only bypasses the
+     * "must @-mention the bot" requirement, not access control.
+     */
+    mentionSatisfied?: boolean;
 }): Promise<GateResult>;

package/src/messaging/inbound/gate.js

@@ -216,7 +216,7 @@ function checkBotSenderGate(params) {
 // Internal: group gate
 // ---------------------------------------------------------------------------
 function checkGroupGate(params) {
-    const { ctx, accountFeishuCfg, account, accountScopedCfg, log } = params;
+    const { ctx, accountFeishuCfg, account, accountScopedCfg, log, mentionSatisfied } = params;
     const core = lark_client_1.LarkClient.runtime;
     // ---- Layer 1: Group-level admission (shared with bot path) ----
     const access = resolveFeishuGroupAccess(params);
@@ -259,7 +259,7 @@ function checkGroupGate(params) {
         groupIdCaseInsensitive: true,
         requireMentionOverride: accountFeishuCfg?.requireMention,
     });
-    if (requireMention && !(0, mention_1.mentionedBot)(ctx)) {
+    if (requireMention && !(0, mention_1.mentionedBot)(ctx) && !mentionSatisfied) {
         // Check if @all mention should bypass the mention requirement
         if (ctx.mentionAll) {
             const respondToAll = resolveRespondToMentionAll({

package/src/messaging/inbound/handler-registry.d.ts

@@ -17,6 +17,10 @@ export interface InboundHandlerParams {
     accountId?: string;
     replyToMessageId?: string;
     forceMention?: boolean;
+    /** Run the real access-control gate but treat the mention requirement as
+     *  satisfied (card-action synthetic messages). Takes precedence over
+     *  forceMention. See handleFeishuMessage. */
+    cardActionGate?: boolean;
     skipTyping?: boolean;
 }
 type InboundHandler = (params: InboundHandlerParams) => Promise<void>;

package/src/messaging/inbound/handler.d.ts

@@ -32,6 +32,12 @@ export declare function handleFeishuMessage(params: {
     /** When true, skip the policy gate (mention requirement, allowlist).
      *  Used for synthetic messages that are not real user messages. */
     forceMention?: boolean;
+    /** When true, run the real access-control gate but treat the mention
+     *  requirement as already satisfied. Used for card-action synthetic messages:
+     *  the click is an explicit user action targeting the bot (implicit mention),
+     *  but group/DM admission and sender allowlists must still be enforced.
+     *  Takes precedence over forceMention. */
+    cardActionGate?: boolean;
     /** When true, skip the typing indicator for this dispatch (e.g. reactions). */
     skipTyping?: boolean;
 }): Promise<void>;

package/src/messaging/inbound/handler.js

@@ -40,7 +40,7 @@ const logger = (0, lark_logger_1.larkLogger)('inbound/handler');
 // Public: handle inbound message
 // ---------------------------------------------------------------------------
 async function handleFeishuMessage(params) {
-    const { cfg, event, botOpenId, runtime, chatHistories, accountId, replyToMessageId, forceMention, skipTyping } = params;
+    const { cfg, event, botOpenId, runtime, chatHistories, accountId, replyToMessageId, forceMention, cardActionGate, skipTyping, } = params;
     // 1. Account resolution
     const account = (0, accounts_1.getLarkAccount)(cfg, accountId);
     const accountFeishuCfg = account.config;
@@ -116,10 +116,21 @@ async function handleFeishuMessage(params) {
     log(`feishu[${account.accountId}]: received message from ${ctx.senderId} in ${ctx.chatId} (${ctx.chatType})`);
     logger.info(`received from ${ctx.senderId} in ${ctx.chatId} (${ctx.chatType})`);
     const historyLimit = Math.max(0, accountFeishuCfg?.historyLimit ?? accountScopedCfg.messages?.groupChat?.historyLimit ?? reply_history_1.DEFAULT_GROUP_HISTORY_LIMIT);
-    // 5. Gate: policy / access-control checks (skipped for synthetic messages)
-    const gate = forceMention
+    // 5. Gate: policy / access-control checks (skipped for synthetic messages).
+    //    cardActionGate runs the real gate with the mention requirement treated as
+    //    satisfied (the click is an implicit mention) — it takes precedence over
+    //    forceMention so card actions are still subject to group/DM admission and
+    //    sender allowlists.
+    const gate = forceMention && !cardActionGate
         ? { allowed: true }
-        : await (0, gate_1.checkMessageGate)({ ctx, accountFeishuCfg, account, accountScopedCfg, log });
+        : await (0, gate_1.checkMessageGate)({
+            ctx,
+            accountFeishuCfg,
+            account,
+            accountScopedCfg,
+            log,
+            mentionSatisfied: cardActionGate,
+        });
     if (!gate.allowed) {
         if (gate.reason === 'no_mention') {
             logger.info(`rejected: no bot mention in group ${ctx.chatId}`);

package/src/messaging/inbound/synthetic-message.d.ts

@@ -23,4 +23,9 @@ export declare function dispatchSyntheticTextMessage(params: {
         error?: (msg: string) => void;
     };
     forceMention?: boolean;
+    /** When true, run the real access-control gate with the mention requirement
+     *  treated as satisfied (see handleFeishuMessage.cardActionGate). Use for
+     *  card-action synthetic messages so group/DM admission + sender allowlists
+     *  are still enforced. Takes precedence over forceMention. */
+    cardActionGate?: boolean;
 }): Promise<string>;

package/src/messaging/inbound/synthetic-message.js

@@ -15,7 +15,7 @@ const lark_ticket_1 = require("../../core/lark-ticket.js");
 const handler_registry_1 = require("./handler-registry.js");
 async function dispatchSyntheticTextMessage(params) {
     const handleFeishuMessage = (0, handler_registry_1.getInboundHandler)();
-    const { cfg, accountId, chatId, senderOpenId, text, syntheticMessageId, replyToMessageId, chatType, threadId, runtime, forceMention = true, } = params;
+    const { cfg, accountId, chatId, senderOpenId, text, syntheticMessageId, replyToMessageId, chatType, threadId, runtime, forceMention = true, cardActionGate, } = params;
     const syntheticEvent = {
         sender: {
             sender_id: { open_id: senderOpenId },
@@ -48,6 +48,7 @@ async function dispatchSyntheticTextMessage(params) {
                 event: syntheticEvent,
                 accountId,
                 forceMention,
+                cardActionGate,
                 // eslint-disable-next-line @typescript-eslint/no-explicit-any
                 runtime: runtime,
                 replyToMessageId,

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

@@ -173,13 +173,15 @@ function handleAskUserAction(data, _cfg, accountId) {
         openChatId = event.open_chat_id ?? event.context?.open_chat_id;
         const actionTag = event.action?.tag;
         const actionName = event.action?.name;
+        const formName = event.action?.form_name;
         formValue = event.action?.form_value;
         log.info(`card action received: tag=${actionTag}, name=${actionName}, chat=${openChatId}, ` +
             `sender=${senderOpenId}, hasFormValue=${!!formValue}, hasValue=${!!event.action?.value}`);
         // Extract action/operationId from button value (may not propagate for form submit)
         const val = event.action?.value;
         if (val && typeof val === 'object') {
-            action = val.action;
+            const valueAction = val.action;
+            action = valueAction === ACTION_SUBMIT ? ACTION_SUBMIT : undefined;
             operationId = val.operation_id;
         }
         // Detect form submit by button name
@@ -196,7 +198,13 @@ function handleAskUserAction(data, _cfg, accountId) {
             action = ACTION_SUBMIT;
         }
         // Some SDK versions emit tag='form_submit' without button value/name.
-        if (!action && actionTag === 'form_submit' && (!actionName || actionName.startsWith(SUBMIT_BUTTON_PREFIX))) {
+        // Business plugins also use form_submit; a form_name means it belongs to
+        // the named business form, while absent form_name keeps the old AskUser
+        // chat-scoped fallback for legacy callbacks.
+        if (!action &&
+            actionTag === 'form_submit' &&
+            !formName &&
+            (!actionName || actionName.startsWith(SUBMIT_BUTTON_PREFIX))) {
             action = ACTION_SUBMIT;
             if (!formValue && event.action) {
                 formValue = event.action;

package/tsdown.config.d.ts

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

package/vitest.config.d.ts

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