@larksuite/openclaw-lark 2026.4.9-beta.0 → 2026.4.9

package/package.json

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

package/skills/feishu-task/SKILL.md

@@ -9,6 +9,9 @@ description: |
   (3) 需要查看任务列表或清单内的任务
   (4) 用户提到"任务"、"待办"、"to-do"、"清单"、"task"
   (5) 需要设置任务负责人、关注人、截止时间、添加成员
+  (6) 需要追加任务步骤记录（Task 的 steps）
+  (7) 需要上传任务附件（支持 task / task_delivery）
+  (8) 需要注册 Agent / 更新 Agent 信息（register / update_profile）
 ---
 
 # 飞书任务管理
@@ -17,11 +20,13 @@ description: |
 
 - ✅ **时间格式**：ISO 8601 / RFC 3339（带时区），例如 `2026-02-28T17:00:00+08:00`
 - ✅ **身份授权**：工具支持 `auth_type` 为 `user`（默认，用户身份）或 `tenant`（应用身份）。
+- ✅ **任务 Agent（feishu_task_agent）**：仅支持应用身份（tenant），不支持 user 身份
 - ✅ **current_user_id 强烈建议**：从消息上下文的 SenderId 获取（ou_...），工具会自动添加为 follower（如不在 members 中），确保创建者可以编辑任务
 - ✅ **patch/get 必须**：task_guid
 - ✅ **tasklist.tasks 必须**：tasklist_guid
 - ✅ **完成任务**：completed_at = "2026-02-26 15:00:00"
 - ✅ **反完成（恢复未完成）**：completed_at = "0"
+- ✅ **append_steps 的 task_steps[].timestamp**：秒级 Unix 时间戳（10 位），不要用毫秒（13 位）
 
 ---
 
@@ -30,15 +35,19 @@ description: |
 | 用户意图 | 工具 | action | 必填参数 | 强烈建议 | 常用可选 |
 |---------|------|--------|---------|---------|---------|
 | 新建待办 | feishu_task_task | create | summary | current_user_id（SenderId） | members, due, description, auth_type |
-| 查未完成任务 | feishu_task_task | list | - | completed=false | page_size, auth_type |
+| 查未完成任务 | feishu_task_task | list | - | completed=false | page_size, auth_type, agent_task_status |
 | 获取任务详情 | feishu_task_task | get | task_guid | - | auth_type |
 | 完成任务 | feishu_task_task | patch | task_guid, completed_at | - | auth_type |
 | 反完成任务 | feishu_task_task | patch | task_guid, completed_at="0" | - | auth_type |
 | 改截止时间 | feishu_task_task | patch | task_guid, due | - | auth_type |
 | 添加任务成员 | feishu_task_task | add_members | task_guid, members[] | - | auth_type |
+| 追加任务步骤记录 | feishu_task_task | append_steps | task_guid, idempotent_key, task_steps[] | task_steps[].timestamp 用秒级（10 位） | - |
 | 创建清单 | feishu_task_tasklist | create | name | - | members |
 | 查看清单任务 | feishu_task_tasklist | tasks | tasklist_guid | - | completed |
 | 添加清单成员 | feishu_task_tasklist | add_members | tasklist_guid, members[] | - | - |
+| 上传任务附件 | feishu_task_attachment | upload | resource_id, file(base64) | name | resource_type |
+| 注册任务 Agent | feishu_task_agent | register | - | 仅支持 tenant（应用身份） | - |
+| 更新任务 Agent Profile | feishu_task_agent | update_profile | profile_content | 仅支持 tenant（应用身份） | - |
 
 ---
 
@@ -233,6 +242,25 @@ description: |
 }
 ```
 
+### 场景 9: 注册任务 Agent（仅应用身份）
+
+```json
+{
+  "action": "register",
+  "auth_type": "tenant"
+}
+```
+
+### 场景 10: 更新任务 Agent Profile（仅应用身份）
+
+```json
+{
+  "action": "update_profile",
+  "auth_type": "tenant",
+  "profile_content": "some profile content"
+}
+```
+
 ---
 
 ## 🔍 常见错误与排查

package/src/channel/event-handlers.d.ts

@@ -12,5 +12,6 @@ import type { MonitorContext } from './types';
 export declare function handleMessageEvent(ctx: MonitorContext, data: unknown): Promise<void>;
 export declare function handleReactionEvent(ctx: MonitorContext, data: unknown): Promise<void>;
 export declare function handleBotMembershipEvent(ctx: MonitorContext, data: unknown, action: 'added' | 'removed'): Promise<void>;
+export declare function handleVcMeetingInvitedEvent(ctx: MonitorContext, data: unknown): Promise<void>;
 export declare function handleCommentEvent(ctx: MonitorContext, data: unknown): Promise<void>;
 export declare function handleCardActionEvent(ctx: MonitorContext, data: unknown): Promise<unknown>;

package/src/channel/event-handlers.js

@@ -13,11 +13,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.handleMessageEvent = handleMessageEvent;
 exports.handleReactionEvent = handleReactionEvent;
 exports.handleBotMembershipEvent = handleBotMembershipEvent;
+exports.handleVcMeetingInvitedEvent = handleVcMeetingInvitedEvent;
 exports.handleCommentEvent = handleCommentEvent;
 exports.handleCardActionEvent = handleCardActionEvent;
 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");
+const vc_meeting_invited_handler_1 = require("../messaging/inbound/vc-meeting-invited-handler.js");
+const vc_sender_1 = require("../messaging/inbound/vc-sender.js");
 const comment_context_1 = require("../messaging/inbound/comment-context.js");
 const dedup_1 = require("../messaging/inbound/dedup.js");
 const lark_ticket_1 = require("../core/lark-ticket.js");
@@ -223,6 +226,76 @@ async function handleBotMembershipEvent(ctx, data, action) {
     }
 }
 // ---------------------------------------------------------------------------
+// VC meeting invited handler
+// ---------------------------------------------------------------------------
+async function handleVcMeetingInvitedEvent(ctx, data) {
+    if (!isEventOwnershipValid(ctx, data))
+        return;
+    const { accountId, log, error } = ctx;
+    try {
+        const event = data;
+        const meetingNo = event.meeting?.meeting_no?.trim() ?? '';
+        const eventId = event.event_id?.trim() ?? '';
+        // Resolve the inviter identity through the shared helper so the
+        // diagnostics log and the dispatch handler always agree on the
+        // same sender semantics.
+        const sender = (0, vc_sender_1.resolveVcSender)(event);
+        const senderId = sender.senderId;
+        const invitedBotOpenId = event.bot?.id?.open_id?.trim() ?? '';
+        // VC invited origin/ownership diagnostics:
+        // - This handler is only reachable from the WebSocket monitor path.
+        // - We still log app_id/bot_open_id so operators can confirm the event
+        //   is delivered to the expected bot/account, and see which required
+        //   fields are missing when we skip.
+        const expectedAppId = ctx.lark.account.appId ?? '';
+        const eventAppId = event.app_id?.trim() ?? '';
+        log(`feishu[${accountId}]: vc invited event received (ingress=websocket)` +
+            `${eventId ? ` event_id=${eventId}` : ''}` +
+            `${eventAppId ? ` app_id=${eventAppId}` : ' app_id=<missing>'}` +
+            `${expectedAppId ? ` expected_app_id=${expectedAppId}` : ''}` +
+            `${invitedBotOpenId ? ` bot_open_id=${invitedBotOpenId}` : ' bot_open_id=<missing>'}` +
+            `${ctx.lark.botOpenId ? ` expected_bot_open_id=${ctx.lark.botOpenId}` : ''}` +
+            `${event.invite_time ? ` invite_time=${event.invite_time}` : ''}` +
+            ` meeting_no_present=${meetingNo ? 'true' : 'false'}` +
+            ` sender_present=${senderId ? 'true' : 'false'}` +
+            ` sender_from=${sender.fromFallback}`);
+        if (!meetingNo) {
+            log(`feishu[${accountId}]: vc invited event missing meeting_no, skipping`);
+            return;
+        }
+        if (!senderId) {
+            log(`feishu[${accountId}]: vc invited event missing inviter identity, skipping`);
+            return;
+        }
+        if (ctx.lark.botOpenId && invitedBotOpenId && invitedBotOpenId !== ctx.lark.botOpenId) {
+            log(`feishu[${accountId}]: vc invited event for another bot, expected=${ctx.lark.botOpenId}, got=${invitedBotOpenId}, skipping`);
+            return;
+        }
+        // Prefer event_id when the SDK exposes it: historical raw payload logs
+        // show WebSocket reconnect replays reuse the same event_id, while a real
+        // second invitation yields a new event_id even for the same meeting/bot.
+        // Fallback to (meeting_no, bot) only when event_id is absent so older
+        // payload shapes still remain deduplicated.
+        const dedupBotKey = ctx.lark.botOpenId ?? invitedBotOpenId ?? 'no-bot';
+        const dedupKey = eventId ? `vc-invited:by-event:${eventId}` : `vc-invited:by-meeting:${meetingNo}:${dedupBotKey}`;
+        if (!ctx.messageDedup.tryRecord(dedupKey, accountId)) {
+            log(`feishu[${accountId}]: duplicate vc invited event detected, skipping`);
+            return;
+        }
+        log(`feishu[${accountId}]: vc invited event accepted for synthetic dispatch`);
+        await (0, vc_meeting_invited_handler_1.handleFeishuVcMeetingInvited)({
+            cfg: ctx.cfg,
+            event,
+            runtime: ctx.runtime,
+            chatHistories: ctx.chatHistories,
+            accountId,
+        });
+    }
+    catch (err) {
+        error(`feishu[${accountId}]: error handling vc invited event: ${String(err)}`);
+    }
+}
+// ---------------------------------------------------------------------------
 // Drive comment handler
 // ---------------------------------------------------------------------------
 async function handleCommentEvent(ctx, data) {

package/src/channel/monitor.js

@@ -77,6 +77,7 @@ async function monitorSingleAccount(params) {
             'im.chat.access_event.bot_p2p_chat_entered_v1': async () => { },
             'im.chat.member.bot.added_v1': (data) => (0, event_handlers_1.handleBotMembershipEvent)(ctx, data, 'added'),
             'im.chat.member.bot.deleted_v1': (data) => (0, event_handlers_1.handleBotMembershipEvent)(ctx, data, 'removed'),
+            'vc.bot.meeting_invited_v1': (data) => (0, event_handlers_1.handleVcMeetingInvitedEvent)(ctx, data),
             // Drive comment event — fires when a user adds a comment or reply on a document.
             'drive.notice.comment_add_v1': (data) => (0, event_handlers_1.handleCommentEvent)(ctx, data),
             // 飞书 SDK EventDispatcher.register 不支持带返回值的处理器，此处 as any 是 SDK 类型限制的变通

package/src/core/synthetic-target.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Synthetic IM target utilities.
+ *
+ * Some inbound flows (VC meeting-invited, other service-triggered events)
+ * do not map to a real IM chat — there is no chat_id / open_id the agent
+ * should send messages into. To keep the dispatch pipeline uniform we give
+ * these flows a sentinel chatId ("synthetic:<kind>") and teach outbound
+ * deliverers to short-circuit whenever they see this prefix. This is the
+ * same pattern used by `core/comment-target.ts` for Drive comment threads.
+ */
+/** Sentinel chatId for VC `vc.bot.meeting_invited_v1` synthetic inbound. */
+export declare const SYNTHETIC_VC_CHAT_ID = "synthetic:vc-invited";
+/**
+ * The `chatType` stamped on synthetic VC contexts.
+ *
+ * `MessageContext.chatType` is currently typed as `'p2p' | 'group'` across
+ * the plugin and widening that union touches every downstream signature.
+ * 'p2p' is the closest match (single-peer, non-group) and the outbound
+ * short-circuit gates on the sentinel chatId — not the chatType — so this
+ * choice does not produce any DMs on its own.
+ *
+ * TODO(synthetic-target): widen MessageContext.chatType to include
+ * `synthetic` once downstream signatures are audited.
+ */
+export declare const SYNTHETIC_VC_CHAT_TYPE: "p2p";
+/**
+ * Return `true` when `target` is a synthetic sentinel that outbound
+ * deliverers should not try to send an IM message to.
+ */
+export declare function isSyntheticTarget(target: string | undefined | null): boolean;

package/src/core/synthetic-target.js

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Synthetic IM target utilities.
+ *
+ * Some inbound flows (VC meeting-invited, other service-triggered events)
+ * do not map to a real IM chat — there is no chat_id / open_id the agent
+ * should send messages into. To keep the dispatch pipeline uniform we give
+ * these flows a sentinel chatId ("synthetic:<kind>") and teach outbound
+ * deliverers to short-circuit whenever they see this prefix. This is the
+ * same pattern used by `core/comment-target.ts` for Drive comment threads.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SYNTHETIC_VC_CHAT_TYPE = exports.SYNTHETIC_VC_CHAT_ID = void 0;
+exports.isSyntheticTarget = isSyntheticTarget;
+const SYNTHETIC_PREFIX = 'synthetic:';
+/** Sentinel chatId for VC `vc.bot.meeting_invited_v1` synthetic inbound. */
+exports.SYNTHETIC_VC_CHAT_ID = 'synthetic:vc-invited';
+/**
+ * The `chatType` stamped on synthetic VC contexts.
+ *
+ * `MessageContext.chatType` is currently typed as `'p2p' | 'group'` across
+ * the plugin and widening that union touches every downstream signature.
+ * 'p2p' is the closest match (single-peer, non-group) and the outbound
+ * short-circuit gates on the sentinel chatId — not the chatType — so this
+ * choice does not produce any DMs on its own.
+ *
+ * TODO(synthetic-target): widen MessageContext.chatType to include
+ * `synthetic` once downstream signatures are audited.
+ */
+exports.SYNTHETIC_VC_CHAT_TYPE = 'p2p';
+/**
+ * Return `true` when `target` is a synthetic sentinel that outbound
+ * deliverers should not try to send an IM message to.
+ */
+function isSyntheticTarget(target) {
+    return Boolean(target && target.startsWith(SYNTHETIC_PREFIX));
+}

package/src/core/targets.js

@@ -145,7 +145,6 @@ function resolveReceiveIdType(id) {
         return 'chat_id';
     if (id.startsWith(OPEN_ID_PREFIX))
         return 'open_id';
-    // Default to open_id for any other pattern (safer for outbound API calls).
     return 'open_id';
 }
 function normalizeMessageId(messageId) {

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

@@ -22,6 +22,8 @@ export declare function dispatchToAgent(params: {
     ctx: MessageContext;
     permissionError?: PermissionError;
     mediaPayload: Record<string, unknown>;
+    /** Additional structured metadata for synthetic or event-driven inbound flows. */
+    extraInboundFields?: Record<string, unknown>;
     quotedContent?: string;
     account: LarkAccount;
     /** account 级别的 ClawdbotConfig（channels.feishu 已替换为 per-account 合并后的配置） */

package/src/messaging/inbound/dispatch.js

@@ -26,6 +26,7 @@ const tool_use_trace_store_1 = require("../../card/tool-use-trace-store.js");
 const abort_detect_1 = require("../../channel/abort-detect.js");
 const chat_info_cache_1 = require("../../core/chat-info-cache.js");
 const comment_target_1 = require("../../core/comment-target.js");
+const synthetic_target_1 = require("../../core/synthetic-target.js");
 const targets_1 = require("../../core/targets.js");
 const deliver_1 = require("../outbound/deliver.js");
 const doctor_1 = require("../../commands/doctor.js");
@@ -94,7 +95,81 @@ async function dispatchCommentMessage(dc, ctxPayload, skillFilter) {
     dc.log(`feishu[${dc.account.accountId}]: comment dispatch complete (delivered=${delivered})`);
     log.info(`comment dispatch complete (delivered=${delivered}, elapsed=${(0, lark_ticket_1.ticketElapsed)()}ms)`);
 }
+/**
+ * Dispatch a synthetic-target message via the buffered block dispatcher
+ * while discarding every delivered payload.
+ *
+ * Synthetic contexts (e.g. VC meeting-invited) trigger the agent for its
+ * side-effects (tool calls) — they do not correspond to a real IM chat,
+ * so any text / card the agent emits must be dropped instead of being
+ * sent as a DM to whatever open_id happens to be in ctx.chatId.
+ */
+async function dispatchSyntheticMessage(dc, ctxPayload, skillFilter) {
+    const effectiveSessionKey = dc.threadSessionKey ?? dc.route.sessionKey;
+    const isVcSynthetic = dc.ctx.chatId === synthetic_target_1.SYNTHETIC_VC_CHAT_ID;
+    let deliveredFinalToSender = false;
+    dc.log(`feishu[${dc.account.accountId}]: dispatching synthetic reply (session=${effectiveSessionKey}, target=${dc.ctx.chatId})`);
+    log.info(`dispatching synthetic reply (session=${effectiveSessionKey})`);
+    await dc.core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+        ctx: ctxPayload,
+        cfg: dc.accountScopedCfg,
+        dispatcherOptions: {
+            deliver: async (payload, info) => {
+                const text = payload.text?.trim() ?? '';
+                const preview = text.slice(0, 120);
+                // VC invited flows intentionally keep the synthetic target to avoid
+                // leaking intermediate tool output to IM, but the final business
+                // result should be explicitly notified to the inviter.
+                //
+                // Important: this DM is only a transport bridge for the final text.
+                // It does not rebind the inviter's DM conversation to the synthetic
+                // meeting-scoped session; later DM replies will still be routed by the
+                // normal OpenClaw DM session rules.
+                if (isVcSynthetic && info.kind === 'final' && text && text !== 'NO_REPLY' && !deliveredFinalToSender) {
+                    deliveredFinalToSender = true;
+                    try {
+                        await (0, send_1.sendMessageFeishu)({
+                            cfg: dc.accountScopedCfg,
+                            to: dc.ctx.senderId,
+                            text,
+                            accountId: dc.account.accountId,
+                        });
+                        dc.log(`feishu[${dc.account.accountId}]: synthetic VC final delivered explicitly to sender=${dc.ctx.senderId}, preview="${preview}"`);
+                        return;
+                    }
+                    catch (err) {
+                        deliveredFinalToSender = false;
+                        dc.error(`feishu[${dc.account.accountId}]: synthetic VC final delivery failed to sender=${dc.ctx.senderId}: ${String(err)}`);
+                    }
+                }
+                if (info.kind === 'final') {
+                    dc.log(`feishu[${dc.account.accountId}]: synthetic final payload dropped (target=${dc.ctx.chatId})`);
+                }
+            },
+            onSkip: (_payload, info) => {
+                if (info.reason !== 'silent') {
+                    dc.log(`feishu[${dc.account.accountId}]: synthetic reply skipped (reason=${info.reason})`);
+                }
+            },
+            onError: (err, info) => {
+                dc.error(`feishu[${dc.account.accountId}]: synthetic ${info.kind} reply failed: ${String(err)}`);
+            },
+        },
+        replyOptions: {
+            ...(skillFilter ? { skillFilter } : {}),
+        },
+    });
+    dc.log(`feishu[${dc.account.accountId}]: synthetic dispatch complete (elapsed=${(0, lark_ticket_1.ticketElapsed)()}ms)`);
+}
 async function dispatchNormalMessage(dc, ctxPayload, chatHistories, historyKey, historyLimit, replyToMessageId, skillFilter, skipTyping) {
+    // Synthetic targets (e.g. VC meeting-invited) have no real IM peer to
+    // deliver replies to. Route them through the buffered block dispatcher
+    // with a deliver() that drops every payload — the agent still runs
+    // (tool calls, side-effects) but produces no outbound IM traffic.
+    if ((0, synthetic_target_1.isSyntheticTarget)(dc.ctx.chatId)) {
+        await dispatchSyntheticMessage(dc, ctxPayload, skillFilter);
+        return;
+    }
     // Comment targets bypass the streaming card / IM flow entirely —
     // route through the Drive comment reply API.
     if ((0, comment_target_1.isCommentTarget)(dc.ctx.chatId)) {
@@ -277,6 +352,7 @@ async function dispatchToAgent(params) {
         inboundHistory,
         extraFields: {
             ...params.mediaPayload,
+            ...(params.extraInboundFields ?? {}),
             ...(groupSystemPrompt ? { GroupSystemPrompt: groupSystemPrompt } : {}),
             ...(dc.ctx.threadId ? { MessageThreadId: dc.ctx.threadId } : {}),
         },

package/src/messaging/inbound/vc-meeting-invited-handler.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * VC meeting invited event handler for the Lark/Feishu channel plugin.
+ *
+ * Handles `vc.bot.meeting_invited_v1` by converting the event into a
+ * synthetic natural-language inbound and dispatching it through the
+ * standard OpenClaw agent pipeline.
+ */
+import type { ClawdbotConfig, RuntimeEnv } from 'openclaw/plugin-sdk';
+import type { HistoryEntry } from 'openclaw/plugin-sdk/reply-history';
+import type { FeishuVcMeetingInvitedEvent } from '../types';
+export declare function handleFeishuVcMeetingInvited(params: {
+    cfg: ClawdbotConfig;
+    event: FeishuVcMeetingInvitedEvent;
+    runtime?: RuntimeEnv;
+    chatHistories?: Map<string, HistoryEntry[]>;
+    accountId?: string;
+}): Promise<void>;

package/src/messaging/inbound/vc-meeting-invited-handler.js

@@ -0,0 +1,226 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * VC meeting invited event handler for the Lark/Feishu channel plugin.
+ *
+ * Handles `vc.bot.meeting_invited_v1` by converting the event into a
+ * synthetic natural-language inbound and dispatching it through the
+ * standard OpenClaw agent pipeline.
+ */
+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.handleFeishuVcMeetingInvited = handleFeishuVcMeetingInvited;
+const crypto = __importStar(require("node:crypto"));
+const synthetic_target_1 = require("../../core/synthetic-target.js");
+const accounts_1 = require("../../core/accounts.js");
+const lark_logger_1 = require("../../core/lark-logger.js");
+const dispatch_1 = require("./dispatch.js");
+const gate_effects_1 = require("./gate-effects.js");
+const gate_1 = require("./gate.js");
+const policy_1 = require("./policy.js");
+const vc_sender_1 = require("./vc-sender.js");
+const logger = (0, lark_logger_1.larkLogger)('inbound/vc-meeting-invited-handler');
+function buildSyntheticEvent(event) {
+    const meetingNo = event.meeting?.meeting_no?.trim() ?? '';
+    // Both meeting_no and inviter identity are required for this event.
+    if (!meetingNo) {
+        return null;
+    }
+    const sender = (0, vc_sender_1.resolveVcSender)(event);
+    if (!sender.senderId) {
+        return null;
+    }
+    return {
+        eventType: 'vc.bot.meeting_invited_v1',
+        source: 'feishu-vc-event',
+        eventId: event.event_id?.trim() || undefined,
+        meetingId: event.meeting?.id?.trim() || undefined,
+        meetingNo,
+        topic: event.meeting?.topic?.trim() || undefined,
+        senderId: sender.senderId,
+        senderOpenId: sender.senderOpenId,
+        senderUserId: sender.senderUserId,
+        senderUnionId: sender.senderUnionId,
+        senderName: sender.senderName,
+        inviteTime: event.invite_time?.trim() || undefined,
+    };
+}
+function buildSyntheticContext(event) {
+    // Keep the synthetic inbound prompt in English for now: it is an
+    // agent-facing intent string rather than user-visible copy, and the final
+    // reply language is still governed by the agent/session prompt stack.
+    // If we later need locale-aware synthetic prompts, this is the single place
+    // to introduce a template or config-based language switch.
+    const syntheticText = `Join the meeting with meeting number ${event.meetingNo}.`;
+    const syntheticMessageId = event.eventId
+        ? `vc-invited:event:${event.eventId}`
+        : `vc-invited:${event.meetingNo}:${event.inviteTime ?? crypto.randomUUID()}`;
+    // VC-invited events have no real chat/thread — they are service-to-service
+    // triggers. Using the inviter's open_id as chatId would cause downstream
+    // senders (reply / card / media) to fire off unsolicited DMs to the inviter
+    // whenever the agent produced any output. Use a synthetic sentinel instead
+    // and let IM-facing deliverers short-circuit on it (see SYNTHETIC_VC_CHAT_ID).
+    return {
+        chatId: synthetic_target_1.SYNTHETIC_VC_CHAT_ID,
+        messageId: syntheticMessageId,
+        senderId: event.senderId,
+        senderName: event.senderName,
+        chatType: synthetic_target_1.SYNTHETIC_VC_CHAT_TYPE,
+        content: syntheticText,
+        contentType: 'text',
+        resources: [],
+        mentions: [],
+        mentionAll: false,
+        rawMessage: {
+            message_id: syntheticMessageId,
+            chat_id: synthetic_target_1.SYNTHETIC_VC_CHAT_ID,
+            chat_type: synthetic_target_1.SYNTHETIC_VC_CHAT_TYPE,
+            message_type: 'text',
+            content: JSON.stringify({ text: syntheticText }),
+            create_time: event.inviteTime ?? String(Date.now()),
+        },
+        rawSender: {
+            sender_id: {
+                ...(event.senderOpenId ? { open_id: event.senderOpenId } : {}),
+                ...(event.senderUserId ? { user_id: event.senderUserId } : {}),
+                ...(event.senderUnionId ? { union_id: event.senderUnionId } : {}),
+            },
+            sender_type: 'user',
+        },
+    };
+}
+function matchesAnySenderId(params) {
+    const candidates = [...new Set(params.senderIds.map((id) => id?.trim()).filter(Boolean))];
+    return candidates.some((candidate) => (0, policy_1.resolveFeishuAllowlistMatch)({
+        allowFrom: params.allowFrom,
+        senderId: candidate,
+    }).allowed);
+}
+async function handleFeishuVcMeetingInvited(params) {
+    const { cfg, event, runtime, chatHistories, accountId } = params;
+    const log = runtime?.log ?? ((...args) => logger.info(args.map(String).join(' ')));
+    const error = runtime?.error ?? ((...args) => logger.error(args.map(String).join(' ')));
+    const syntheticEvent = buildSyntheticEvent(event);
+    if (!syntheticEvent) {
+        log(`feishu[${accountId}]: vc invited event missing meeting_no or inviter identity, skipping`);
+        return;
+    }
+    const account = (0, accounts_1.getLarkAccount)(cfg, accountId);
+    const accountScopedCfg = {
+        ...cfg,
+        channels: { ...cfg.channels, feishu: account.config },
+    };
+    const accountFeishuCfg = account.config;
+    // ---- Access policy enforcement (DM-style) ----
+    // VC invited events are user-triggered service events. Align their access
+    // semantics with direct-message/comment flows so unpaired users cannot
+    // trigger agent behavior through event ingress.
+    const dmPolicy = accountFeishuCfg?.dmPolicy ?? 'pairing';
+    if (dmPolicy === 'disabled') {
+        log(`feishu[${accountId}]: vc invited event rejected (dmPolicy=disabled)`);
+        return;
+    }
+    if (dmPolicy !== 'open') {
+        const configAllowFrom = accountFeishuCfg?.allowFrom ?? [];
+        const storeAllowFrom = await (0, gate_1.readFeishuAllowFromStore)(account.accountId).catch(() => []);
+        const combinedAllowFrom = [...configAllowFrom, ...storeAllowFrom];
+        const allowed = matchesAnySenderId({
+            allowFrom: combinedAllowFrom,
+            senderIds: [
+                syntheticEvent.senderOpenId,
+                syntheticEvent.senderUserId,
+                syntheticEvent.senderUnionId,
+            ],
+        });
+        if (!allowed) {
+            if (dmPolicy === 'pairing') {
+                if (syntheticEvent.senderOpenId) {
+                    log(`feishu[${accountId}]: vc inviter not paired, creating pairing request`);
+                    try {
+                        await (0, gate_effects_1.sendPairingReply)({
+                            senderId: syntheticEvent.senderOpenId,
+                            chatId: syntheticEvent.senderOpenId,
+                            accountId: account.accountId,
+                            accountScopedCfg,
+                        });
+                    }
+                    catch (pairingErr) {
+                        log(`feishu[${accountId}]: failed to create pairing request for vc inviter: ${String(pairingErr)}`);
+                    }
+                }
+                else {
+                    log(`feishu[${accountId}]: vc inviter not paired and has no open_id for pairing reply, rejecting`);
+                }
+            }
+            else {
+                log(`feishu[${accountId}]: vc invited event rejected (dmPolicy=${dmPolicy}, inviter not in allowlist)`);
+            }
+            return;
+        }
+    }
+    const ctx = buildSyntheticContext(syntheticEvent);
+    log(`feishu[${accountId}]: vc meeting invited, dispatching synthetic inbound` +
+        ` sender=${syntheticEvent.senderId} meeting_no=${syntheticEvent.meetingNo}`);
+    try {
+        await (0, dispatch_1.dispatchToAgent)({
+            ctx,
+            permissionError: undefined,
+            mediaPayload: {},
+            extraInboundFields: {
+                SyntheticEventType: syntheticEvent.eventType,
+                VcMeetingId: syntheticEvent.meetingId,
+                VcMeetingNo: syntheticEvent.meetingNo,
+                VcMeetingTopic: syntheticEvent.topic,
+                VcInviterOpenId: syntheticEvent.senderOpenId,
+                VcInviteTime: syntheticEvent.inviteTime,
+            },
+            quotedContent: undefined,
+            account,
+            accountScopedCfg,
+            runtime,
+            chatHistories,
+            historyLimit: 0,
+            // VC events do not originate from a real IM message.
+            replyToMessageId: undefined,
+            commandAuthorized: false,
+            skipTyping: true,
+        });
+    }
+    catch (err) {
+        error(`feishu[${accountId}]: error dispatching vc invited synthetic inbound: ${String(err)}`);
+    }
+}

package/src/messaging/inbound/vc-sender.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Shared sender-identity resolution for the VC meeting-invited event.
+ *
+ * Both the raw event handler (for diagnostics / dedup / ownership check)
+ * and the synthetic inbound builder (for dispatchToAgent) need a single,
+ * deterministic fallback chain. Keeping a dedicated module avoids drift
+ * between the two code paths when the event schema changes again.
+ */
+import type { FeishuVcMeetingInvitedEvent } from '../types';
+/** Which bucket the final senderId was picked from. */
+export type VcSenderFallback = 'inviter' | 'none';
+export interface ResolvedVcSender {
+    /**
+     * Final sender id used for logging / extraInboundFields. Sender is defined
+     * as the real inviter only; if inviter identity is missing, the event
+     * should be skipped instead of degrading to bot/config ids.
+     */
+    senderId: string;
+    /** Raw inviter-level open_id (if present); useful for agent "at inviter" use-cases. */
+    senderOpenId?: string;
+    /** Raw inviter-level user_id (if present). */
+    senderUserId?: string;
+    /** Raw inviter-level union_id (if present). */
+    senderUnionId?: string;
+    /** Human-readable name from inviter.user_name. */
+    senderName?: string;
+    /** Which bucket the senderId fell back to. */
+    fromFallback: VcSenderFallback;
+}
+/**
+ * Resolve the effective sender identity for a `vc.bot.meeting_invited_v1`
+ * event. See {@link ResolvedVcSender} for the field contract.
+ *
+ * Sender resolution order (first non-empty wins):
+ *   1. inviter.id.open_id → user_id → union_id
+ *   2. empty string + fromFallback='none'
+ */
+export declare function resolveVcSender(event: FeishuVcMeetingInvitedEvent): ResolvedVcSender;

package/src/messaging/inbound/vc-sender.js

@@ -0,0 +1,53 @@
+"use strict";
+/**
+ * Copyright (c) 2026 ByteDance Ltd. and/or its affiliates
+ * SPDX-License-Identifier: MIT
+ *
+ * Shared sender-identity resolution for the VC meeting-invited event.
+ *
+ * Both the raw event handler (for diagnostics / dedup / ownership check)
+ * and the synthetic inbound builder (for dispatchToAgent) need a single,
+ * deterministic fallback chain. Keeping a dedicated module avoids drift
+ * between the two code paths when the event schema changes again.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resolveVcSender = resolveVcSender;
+/**
+ * Trim a possibly-null identifier and treat the empty string as missing.
+ *
+ * The event schema marks open_id / user_id / union_id as nullable and we
+ * have observed tenants returning empty strings in practice, so `||`/`??`
+ * alone are not enough.
+ */
+function pickId(value) {
+    const trimmed = value?.trim();
+    return trimmed && trimmed.length > 0 ? trimmed : undefined;
+}
+/**
+ * Resolve the effective sender identity for a `vc.bot.meeting_invited_v1`
+ * event. See {@link ResolvedVcSender} for the field contract.
+ *
+ * Sender resolution order (first non-empty wins):
+ *   1. inviter.id.open_id → user_id → union_id
+ *   2. empty string + fromFallback='none'
+ */
+function resolveVcSender(event) {
+    const inviterId = event.inviter?.id;
+    const inviterOpenId = pickId(inviterId?.open_id);
+    const inviterUserId = pickId(inviterId?.user_id);
+    const inviterUnionId = pickId(inviterId?.union_id);
+    let senderId = '';
+    let fromFallback = 'none';
+    if (inviterOpenId ?? inviterUserId ?? inviterUnionId) {
+        senderId = inviterOpenId ?? inviterUserId ?? inviterUnionId ?? '';
+        fromFallback = 'inviter';
+    }
+    return {
+        senderId,
+        senderOpenId: inviterOpenId,
+        senderUserId: inviterUserId,
+        senderUnionId: inviterUnionId,
+        senderName: pickId(event.inviter?.user_name) ?? undefined,
+        fromFallback,
+    };
+}

package/src/messaging/outbound/outbound.js

@@ -6,6 +6,7 @@ const lark_client_1 = require("../../core/lark-client.js");
 const lark_logger_1 = require("../../core/lark-logger.js");
 const targets_1 = require("../../core/targets.js");
 const comment_target_1 = require("../../core/comment-target.js");
+const synthetic_target_1 = require("../../core/synthetic-target.js");
 const deliver_1 = require("./deliver.js");
 const log = (0, lark_logger_1.larkLogger)('outbound/outbound');
 /**
@@ -41,6 +42,13 @@ exports.feishuOutbound = {
     textChunkLimit: 15000,
     sendText: async ({ cfg, to, text, accountId, replyToId, threadId }) => {
         log.info(`sendText: target=${to}, textLength=${text.length}`);
+        // Synthetic targets (e.g. VC meeting-invited) have no real IM peer —
+        // drop the send silently so the agent pipeline stays uniform without
+        // producing unsolicited DMs. See core/synthetic-target.ts.
+        if ((0, synthetic_target_1.isSyntheticTarget)(to)) {
+            log.debug(`sendText: synthetic target ${to}, dropping outbound IM send`);
+            return { channel: 'feishu', messageId: '', chatId: to };
+        }
         // Comment thread routing — route replies through Drive comment API
         if ((0, comment_target_1.isCommentTarget)(to)) {
             log.info(`sendText: detected comment target, routing through Drive comment API`);
@@ -53,6 +61,11 @@ exports.feishuOutbound = {
     },
     sendMedia: async ({ cfg, to, text, mediaUrl, mediaLocalRoots, accountId, replyToId, threadId }) => {
         log.info(`sendMedia: target=${to}, ` + `hasText=${Boolean(text?.trim())}, mediaUrl=${mediaUrl ?? '(none)'}`);
+        // Synthetic targets — drop silently (see sendText for rationale).
+        if ((0, synthetic_target_1.isSyntheticTarget)(to)) {
+            log.debug(`sendMedia: synthetic target ${to}, dropping outbound IM send`);
+            return { channel: 'feishu', messageId: '', chatId: to };
+        }
         // Comment thread routing — send text (with media URL appended) via Drive comment API
         if ((0, comment_target_1.isCommentTarget)(to)) {
             log.info(`sendMedia: detected comment target, routing through Drive comment API`);
@@ -85,6 +98,11 @@ exports.feishuOutbound = {
         };
     },
     sendPayload: async ({ cfg, to, payload, mediaLocalRoots, accountId, replyToId, threadId }) => {
+        // Synthetic targets — drop silently (see sendText for rationale).
+        if ((0, synthetic_target_1.isSyntheticTarget)(to)) {
+            log.debug(`sendPayload: synthetic target ${to}, dropping outbound IM send`);
+            return { channel: 'feishu', messageId: '', chatId: to };
+        }
         const ctx = resolveFeishuSendContext({ cfg, to, accountId, replyToId, threadId });
         // --- channelData.feishu: card message support ---
         const feishuData = payload.channelData?.feishu;

package/src/messaging/types.d.ts

@@ -135,6 +135,69 @@ export interface FeishuBotAddedEvent {
         ja_jp?: string;
     };
 }
+/**
+ * Raw event shape for `vc.bot.meeting_invited_v1`.
+ *
+ * Fired when a user invites the bot to join a meeting.
+ *
+ * Identity fields (for bot / inviter / host_user) are nested under an
+ * `id` object; individual id variants (open_id / user_id / union_id)
+ * may be null depending on the tenant configuration.
+ */
+export interface FeishuVcMeetingInvitedEvent {
+    app_id?: string;
+    event_id?: string;
+    meeting?: {
+        id?: string;
+        meeting_no?: string;
+        topic?: string;
+        host_user?: {
+            id?: {
+                open_id?: string | null;
+                user_id?: string | null;
+                union_id?: string | null;
+            };
+            user_name?: string;
+        };
+    };
+    bot?: {
+        id?: {
+            open_id?: string | null;
+            user_id?: string | null;
+            union_id?: string | null;
+        };
+        user_name?: string;
+    };
+    inviter?: {
+        id?: {
+            open_id?: string | null;
+            user_id?: string | null;
+            union_id?: string | null;
+        };
+        user_name?: string;
+    };
+    invite_time?: string;
+}
+/**
+ * Internal synthetic event model for VC meeting-invited flows.
+ *
+ * This preserves the business semantics before the event is converted into a
+ * synthetic MessageContext for dispatchToAgent().
+ */
+export interface VcMeetingInvitedSyntheticEvent {
+    eventType: 'vc.bot.meeting_invited_v1';
+    source: 'feishu-vc-event';
+    eventId?: string;
+    meetingId?: string;
+    meetingNo: string;
+    topic?: string;
+    senderId: string;
+    senderOpenId?: string;
+    senderUserId?: string;
+    senderUnionId?: string;
+    senderName?: string;
+    inviteTime?: string;
+}
 /** Metadata describing a media resource in a message (no binary data). */
 export interface ResourceDescriptor {
     type: 'image' | 'file' | 'audio' | 'video' | 'sticker';