@meet-im/meet 2.0.6 → 3.0.0-beta.1

package/dist/account-inspect-api.d.ts

@@ -0,0 +1,2 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+export declare function inspectMeetReadOnlyAccount(cfg: OpenClawConfig, accountId?: string | null): import("./src/types.js").ResolvedMeetAccount;

package/dist/account-inspect-api.js

@@ -0,0 +1,4 @@
+import { inspectMeetAccount } from "./src/account-inspect.js";
+export function inspectMeetReadOnlyAccount(cfg, accountId) {
+    return inspectMeetAccount({ cfg, accountId });
+}

package/dist/channel-plugin-api.d.ts

@@ -0,0 +1 @@
+export { meetPlugin } from "./src/channel.js";

package/dist/channel-plugin-api.js

@@ -0,0 +1,3 @@
+// Keep bundled channel entry imports narrow so bootstrap/discovery paths do
+// not drag channel implementation into lightweight entry loads.
+export { meetPlugin } from "./src/channel.js";

package/dist/index.d.ts

@@ -0,0 +1,14 @@
+type MonitorMeetProvider = typeof import("./monitor-api.js").monitorMeetProvider;
+type SendMessageMeet = typeof import("./send-api.js").sendMessageMeet;
+type SendMediaMeet = typeof import("./send-api.js").sendMediaMeet;
+type ResolveMeetMedia = typeof import("./send-api.js").resolveMeetMedia;
+type ProbeMeet = typeof import("./probe-api.js").probeMeet;
+type ClearProbeCache = typeof import("./probe-api.js").clearProbeCache;
+export declare const monitorMeetProvider: MonitorMeetProvider;
+export declare const sendMessageMeet: SendMessageMeet;
+export declare const sendMediaMeet: SendMediaMeet;
+export declare const resolveMeetMedia: ResolveMeetMedia;
+export declare const probeMeet: ProbeMeet;
+export declare const clearProbeCache: ClearProbeCache;
+declare const _default: import("openclaw/plugin-sdk/channel-entry-contract").BundledChannelEntryContract<import("openclaw/plugin-sdk").ChannelPlugin>;
+export default _default;

package/dist/index.js

@@ -0,0 +1,43 @@
+import { defineBundledChannelEntry, loadBundledEntryExportSync, } from "openclaw/plugin-sdk/channel-entry-contract";
+export const monitorMeetProvider = ((...args) => loadBundledEntryExportSync(import.meta.url, {
+    specifier: "./monitor-api.js",
+    exportName: "monitorMeetProvider",
+})(...args));
+export const sendMessageMeet = ((...args) => loadBundledEntryExportSync(import.meta.url, {
+    specifier: "./send-api.js",
+    exportName: "sendMessageMeet",
+})(...args));
+export const sendMediaMeet = ((...args) => loadBundledEntryExportSync(import.meta.url, {
+    specifier: "./send-api.js",
+    exportName: "sendMediaMeet",
+})(...args));
+export const resolveMeetMedia = ((...args) => loadBundledEntryExportSync(import.meta.url, {
+    specifier: "./send-api.js",
+    exportName: "resolveMeetMedia",
+})(...args));
+export const probeMeet = ((...args) => loadBundledEntryExportSync(import.meta.url, {
+    specifier: "./probe-api.js",
+    exportName: "probeMeet",
+})(...args));
+export const clearProbeCache = ((...args) => loadBundledEntryExportSync(import.meta.url, {
+    specifier: "./probe-api.js",
+    exportName: "clearProbeCache",
+})(...args));
+export default defineBundledChannelEntry({
+    id: "meet",
+    name: "Meet",
+    description: "Meet channel plugin",
+    importMetaUrl: import.meta.url,
+    plugin: {
+        specifier: "./channel-plugin-api.js",
+        exportName: "meetPlugin",
+    },
+    runtime: {
+        specifier: "./runtime-setter-api.js",
+        exportName: "setMeetRuntime",
+    },
+    accountInspect: {
+        specifier: "./account-inspect-api.js",
+        exportName: "inspectMeetReadOnlyAccount",
+    },
+});

package/dist/monitor-api.d.ts

@@ -0,0 +1 @@
+export { monitorMeetProvider } from "./src/monitor.js";

package/dist/monitor-api.js

@@ -0,0 +1 @@
+export { monitorMeetProvider } from "./src/monitor.js";

package/dist/probe-api.d.ts

@@ -0,0 +1 @@
+export { probeMeet, clearProbeCache } from "./src/probe.js";

package/dist/probe-api.js

@@ -0,0 +1 @@
+export { probeMeet, clearProbeCache } from "./src/probe.js";

package/dist/runtime-setter-api.d.ts

@@ -0,0 +1 @@
+export { setMeetRuntime } from "./src/runtime.js";

package/dist/runtime-setter-api.js

@@ -0,0 +1,2 @@
+// Keep bundled registration fast: runtime wiring only needs the store setter.
+export { setMeetRuntime } from "./src/runtime.js";

package/dist/send-api.d.ts

@@ -0,0 +1 @@
+export { sendMessageMeet, sendMediaMeet, resolveMeetMedia, } from "./src/send.js";

package/dist/send-api.js

@@ -0,0 +1 @@
+export { sendMessageMeet, sendMediaMeet, resolveMeetMedia, } from "./src/send.js";

package/dist/src/account-inspect.d.ts

@@ -0,0 +1,5 @@
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-types";
+export declare function inspectMeetAccount(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+}): import("./types.js").ResolvedMeetAccount;

package/dist/src/account-inspect.js

@@ -0,0 +1,9 @@
+import { normalizeAccountId } from "openclaw/plugin-sdk/account-id";
+import { resolveDefaultMeetAccountId, resolveMeetAccount } from "./accounts.js";
+export function inspectMeetAccount(params) {
+    const accountId = normalizeAccountId(params.accountId ?? resolveDefaultMeetAccountId(params.cfg));
+    return resolveMeetAccount({
+        cfg: params.cfg,
+        accountId,
+    });
+}

package/dist/src/accounts.d.ts

@@ -0,0 +1,12 @@
+import type { ClawdbotConfig } from "openclaw/plugin-sdk";
+import type { ResolvedMeetAccount } from "./types.js";
+export declare function getFlatAccountKey(accountId: string): string;
+declare function listMeetAccountIds(cfg: ClawdbotConfig): string[];
+declare function resolveDefaultMeetAccountId(cfg: ClawdbotConfig): string;
+export { listMeetAccountIds, resolveDefaultMeetAccountId };
+export declare function isFlatAccountConfig(cfg: ClawdbotConfig, accountId: string): boolean;
+export declare function resolveMeetAccount(params: {
+    cfg: ClawdbotConfig;
+    accountId?: string | null;
+}): ResolvedMeetAccount;
+export declare function listEnabledMeetAccounts(cfg: ClawdbotConfig): ResolvedMeetAccount[];

package/dist/src/accounts.js

@@ -0,0 +1,134 @@
+import { DEFAULT_ACCOUNT_ID, normalizeAccountId, } from "openclaw/plugin-sdk/account-id";
+import { createAccountListHelpers } from "openclaw/plugin-sdk/account-helpers";
+const { listAccountIds: listNestedAccountIds, resolveDefaultAccountId: resolveNestedDefaultAccountId } = createAccountListHelpers("meet");
+const MEET_PREFIX = "meet.";
+export function getFlatAccountKey(accountId) {
+    return `${MEET_PREFIX}${accountId}`;
+}
+function listFlatAccountIds(cfg) {
+    const channels = cfg.channels;
+    if (!channels || typeof channels !== "object") {
+        return [];
+    }
+    const ids = [];
+    for (const key of Object.keys(channels)) {
+        if (key.startsWith(MEET_PREFIX)) {
+            const accountId = key.slice(MEET_PREFIX.length);
+            if (accountId) {
+                ids.push(accountId);
+            }
+        }
+    }
+    return ids;
+}
+function resolveFlatAccountConfig(cfg, accountId) {
+    const key = `${MEET_PREFIX}${accountId}`;
+    const config = cfg.channels?.[key];
+    if (!config || typeof config !== "object") {
+        return undefined;
+    }
+    return config;
+}
+function listMeetAccountIds(cfg) {
+    const nestedIds = listNestedAccountIds(cfg);
+    const flatIds = listFlatAccountIds(cfg);
+    if (flatIds.length > 0) {
+        const filteredNestedIds = nestedIds.filter(id => id !== DEFAULT_ACCOUNT_ID);
+        const allIds = new Set([...filteredNestedIds, ...flatIds]);
+        return [...allIds].sort((a, b) => a.localeCompare(b));
+    }
+    if (nestedIds.length === 0) {
+        return [DEFAULT_ACCOUNT_ID];
+    }
+    return nestedIds;
+}
+function resolveDefaultMeetAccountId(cfg) {
+    const flatIds = listFlatAccountIds(cfg);
+    if (flatIds.length > 0) {
+        const nestedDefault = resolveNestedDefaultAccountId(cfg);
+        if (nestedDefault !== DEFAULT_ACCOUNT_ID && flatIds.includes(nestedDefault)) {
+            return nestedDefault;
+        }
+        return flatIds[0] ?? DEFAULT_ACCOUNT_ID;
+    }
+    return resolveNestedDefaultAccountId(cfg);
+}
+export { listMeetAccountIds, resolveDefaultMeetAccountId };
+export function isFlatAccountConfig(cfg, accountId) {
+    if (accountId === DEFAULT_ACCOUNT_ID) {
+        return false;
+    }
+    return resolveFlatAccountConfig(cfg, accountId) !== undefined;
+}
+function resolveAccountConfig(cfg, accountId) {
+    const nestedConfig = (() => {
+        const accounts = cfg.channels?.meet?.accounts;
+        if (!accounts || typeof accounts !== "object") {
+            return undefined;
+        }
+        return accounts[accountId];
+    })();
+    if (nestedConfig) {
+        return nestedConfig;
+    }
+    return resolveFlatAccountConfig(cfg, accountId);
+}
+function mergeMeetAccountConfig(cfg, accountId) {
+    const meetCfg = cfg.channels?.meet;
+    const { accounts: _ignored, ...base } = meetCfg ?? {};
+    const account = resolveAccountConfig(cfg, accountId) ?? {};
+    const baseGroups = base.groups ?? {};
+    const accountGroups = account.groups ?? {};
+    const mergedGroups = { ...baseGroups, ...accountGroups };
+    return {
+        ...base,
+        ...account,
+        groups: Object.keys(mergedGroups).length > 0 ? mergedGroups : undefined,
+    };
+}
+function resolveMeetToken(cfg, accountId) {
+    const merged = mergeMeetAccountConfig(cfg, accountId);
+    const configToken = merged.token || merged.apiToken;
+    if (configToken) {
+        return {
+            token: configToken,
+            endpoint: merged.apiEndpoint ?? process.env.MEET_API_ENDPOINT ?? "https://staging-meet-api.miyachat.com",
+            source: "config",
+        };
+    }
+    const envToken = process.env.MEET_API_TOKEN;
+    if (envToken) {
+        return {
+            token: envToken,
+            endpoint: merged.apiEndpoint ?? process.env.MEET_API_ENDPOINT ?? "https://staging-meet-api.miyachat.com",
+            source: "env",
+        };
+    }
+    return {
+        token: "",
+        endpoint: "",
+        source: "none",
+    };
+}
+export function resolveMeetAccount(params) {
+    const accountId = normalizeAccountId(params.accountId);
+    const baseEnabled = params.cfg.channels?.meet?.enabled !== false;
+    const merged = mergeMeetAccountConfig(params.cfg, accountId);
+    const accountEnabled = merged.enabled !== false;
+    const enabled = baseEnabled && accountEnabled;
+    const tokenResolution = resolveMeetToken(params.cfg, accountId);
+    return {
+        accountId,
+        enabled,
+        configured: tokenResolution.source !== "none",
+        name: merged.name?.trim() || undefined,
+        apiEndpoint: tokenResolution.endpoint,
+        apiToken: tokenResolution.token,
+        config: merged,
+    };
+}
+export function listEnabledMeetAccounts(cfg) {
+    return listMeetAccountIds(cfg)
+        .map((accountId) => resolveMeetAccount({ cfg, accountId }))
+        .filter((account) => account.enabled && account.configured);
+}

package/dist/src/bot.d.ts

@@ -0,0 +1,15 @@
+import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
+import type { HistoryEntry } from "openclaw/plugin-sdk/reply-history";
+import type { MeetBot, MsgContent } from "@meet-im/meet-bot-jssdk";
+import type { ResolvedMeetAccount } from "./types.js";
+export declare function handleMeetMessage(params: {
+    cfg: ClawdbotConfig;
+    msg: MsgContent;
+    botUserId: string;
+    runtime?: RuntimeEnv;
+    accountId: string;
+    account: ResolvedMeetAccount;
+    bot: MeetBot;
+    groupHistories: Map<string, HistoryEntry[]>;
+    quoteMsgMap?: Record<string, MsgContent>;
+}): Promise<void>;

package/dist/src/bot.js

@@ -0,0 +1,355 @@
+import { buildPendingHistoryContextFromMap, clearHistoryEntriesIfEnabled, recordPendingHistoryEntryIfEnabled, } from "openclaw/plugin-sdk/reply-history";
+import { DEFAULT_ACCOUNT_ID } from "openclaw/plugin-sdk/account-id";
+import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/media-runtime";
+import { msgContentToContext, extractQuoteMessageMedia } from "./sdk-bridge.js";
+import { getMeetRuntime } from "./runtime.js";
+import { resolveMeetAllowlistMatch, resolveMeetGroupPolicy, resolveMeetGroupConfig, resolveMeetGroupUserPolicy } from "./policy.js";
+import { sendMessageMeet } from "./send.js";
+import { resolveMediaAttachments, setMediaDebugLogger } from "./media.js";
+const DEFAULT_GROUP_SYSTEM_PROMPT = "你正在 Meet 群组中对话。请保持回复简洁明了，适合群聊场景。如需回复特定用户，请使用 <@USER_ID> 格式提及对方，例如 <@553>。注意：Meet 不支持用反引号包住 Markdown 语法标记，描述语法时直接写符号，不要加反引号。发送图片或文件时，使用 message 工具的 media 参数，不要用 Markdown 图片语法 ![](path)。";
+const DEFAULT_DM_SYSTEM_PROMPT = "你正在 Meet 私聊中对话。注意：Meet 不支持用反引号包住 Markdown 语法标记，描述语法时直接写符号，不要加反引号。发送图片或文件时，使用 message 工具的 media 参数，不要用 Markdown 图片语法 ![](path)。";
+function formatHistoryEntry(entry) {
+    return `${entry.sender}: ${entry.body}`;
+}
+export async function handleMeetMessage(params) {
+    const { cfg, msg, botUserId, runtime, accountId, account, bot, groupHistories, quoteMsgMap } = params;
+    const log = runtime?.log ?? console.log;
+    const error = runtime?.error ?? console.error;
+    let ctx;
+    try {
+        ctx = msgContentToContext(msg, botUserId, quoteMsgMap);
+    }
+    catch (err) {
+        error(`[${accountId}]: failed to parse message: ${String(err)}`);
+        return;
+    }
+    const isGroup = ctx.chatType === "channel";
+    if (ctx.senderId === botUserId) {
+        log(`[${accountId}]: skipping own message ${ctx.messageId}`);
+        return;
+    }
+    log(`[${accountId}]: received message from ${ctx.senderId} in ${ctx.chatId} (${ctx.chatType})`);
+    const meetCfg = account.config;
+    const dmPolicy = meetCfg.dmPolicy ?? "pairing";
+    const allowFrom = meetCfg.allowFrom ?? [];
+    const historyLimit = isGroup
+        ? Math.max(0, meetCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? 20)
+        : Math.max(0, meetCfg.dmHistoryLimit ?? 0);
+    const speaker = ctx.senderName ?? ctx.senderId;
+    // Discord 做法：文字优先，无文字时用媒体占位符
+    const messageBody = ctx.content.trim()
+        ? `${speaker}: ${ctx.content.trim()}`
+        : `${speaker}: ${ctx.placeholder || ""}`;
+    const pendingEntry = {
+        sender: speaker,
+        body: ctx.content.trim() || ctx.placeholder || "",
+        timestamp: ctx.timestamp,
+        messageId: ctx.messageId,
+    };
+    try {
+        const core = getMeetRuntime();
+        if (!isGroup) {
+            // pairing 模式：需要从 pairing store 读取已授权用户列表
+            // allowlist 模式：只使用配置中的 allowFrom
+            let effectiveAllowFrom = allowFrom;
+            if (dmPolicy === "pairing") {
+                try {
+                    const storeAllowFrom = await core.channel.pairing.readAllowFromStore({
+                        channel: "meet",
+                        accountId,
+                    });
+                    // 合并配置中的 allowFrom 和 store 中的授权列表
+                    effectiveAllowFrom = [...allowFrom, ...storeAllowFrom];
+                }
+                catch (err) {
+                    error(`[${accountId}]: failed to read pairing store: ${String(err)}`);
+                }
+            }
+            const dmAllowed = resolveMeetAllowlistMatch({
+                allowFrom: effectiveAllowFrom,
+                senderId: ctx.senderId,
+            }).allowed;
+            // pairing 模式：创建配对请求并发送授权码给用户
+            // allowlist 模式：直接拒绝未授权用户
+            if (dmPolicy !== "open" && !dmAllowed) {
+                if (dmPolicy === "pairing") {
+                    log(`[${accountId}]: pairing request from ${ctx.senderId}`);
+                    // 创建或更新配对请求
+                    const { code, created } = await core.channel.pairing.upsertPairingRequest({
+                        channel: "meet",
+                        id: ctx.senderId,
+                        accountId,
+                        meta: {
+                            name: ctx.senderName,
+                        },
+                    });
+                    // 发送配对码给用户（新创建或已存在都发送）
+                    if (code) {
+                        const accountArg = accountId === DEFAULT_ACCOUNT_ID ? "" : ` --account ${accountId}`;
+                        const lines = [
+                            "OpenClaw: 尚未授权访问。",
+                            "",
+                            `您的 Meet 用户 ID: ${ctx.senderId}`,
+                            "",
+                            `配对码: ${code}`,
+                            "",
+                            "请联系机器人管理员审批：",
+                            `openclaw pairing approve meet ${code}${accountArg}`,
+                        ];
+                        // 如果是已存在的请求，添加提示
+                        if (!created) {
+                            lines.splice(2, 0, "（您的配对请求已在等待审批中）");
+                        }
+                        const replyText = lines.join("\n");
+                        try {
+                            await sendMessageMeet({
+                                cfg,
+                                to: `user:${ctx.senderId}`,
+                                text: replyText,
+                                accountId,
+                            });
+                        }
+                        catch (err) {
+                            error(`[${accountId}]: failed to send pairing reply to ${ctx.senderId}: ${String(err)}`);
+                        }
+                    }
+                }
+                else {
+                    log(`[${accountId}]: blocked unauthorized sender ${ctx.senderId} (dmPolicy=${dmPolicy})`);
+                }
+                return;
+            }
+        }
+        if (isGroup) {
+            const groupPolicy = resolveMeetGroupPolicy({
+                groupPolicy: meetCfg.groupPolicy,
+                groupAllowFrom: meetCfg.groupAllowFrom ?? [],
+                chatId: ctx.chatId,
+                groups: meetCfg.groups,
+            });
+            if (!groupPolicy.allowed) {
+                log(`[${accountId}]: group ${ctx.chatId} not allowed (groupPolicy=${meetCfg.groupPolicy})`);
+                return;
+            }
+            const groupConfig = resolveMeetGroupConfig({
+                meetConfig: meetCfg,
+                chatId: ctx.chatId,
+            });
+            const groupUserPolicy = resolveMeetGroupUserPolicy({
+                groupConfig: groupConfig.groupConfig,
+                senderId: ctx.senderId,
+            });
+            if (!groupUserPolicy.allowed) {
+                log(`[${accountId}]: user ${ctx.senderId} not allowed in group ${ctx.chatId}`);
+                return;
+            }
+            if (groupConfig.requireMention && !ctx.mentionedBot) {
+                log(`[${accountId}]: message in group ${ctx.chatId} skipped (mention required)`);
+                recordPendingHistoryEntryIfEnabled({
+                    historyMap: groupHistories,
+                    historyKey: ctx.chatId,
+                    entry: pendingEntry,
+                    limit: historyLimit,
+                });
+                return;
+            }
+        }
+        const meetFrom = `meet:${ctx.senderId}`;
+        const meetTo = ctx.chatId;
+        const peerId = isGroup ? ctx.chatId : ctx.senderId;
+        const route = core.channel.routing.resolveAgentRoute({
+            cfg,
+            channel: "meet",
+            accountId,
+            peer: {
+                kind: isGroup ? "group" : "direct",
+                id: peerId,
+            },
+        });
+        // 处理媒体附件
+        let mediaContext = "";
+        let mediaPaths = [];
+        if (ctx.media && ctx.media.length > 0) {
+            log(`[${accountId}]: processing ${ctx.media.length} media attachment(s)`);
+            // 初始化媒体调试日志
+            setMediaDebugLogger(log, error);
+            try {
+                const maxBytes = meetCfg.mediaMaxMb ? meetCfg.mediaMaxMb * 1024 * 1024 : undefined;
+                const mediaInfos = await resolveMediaAttachments({
+                    accountId,
+                    attachments: ctx.media,
+                    sessionInfo: {
+                        firstId: ctx.sessionInfo.firstID,
+                        secondId: ctx.sessionInfo.secondID,
+                        sessionType: ctx.sessionInfo.sessionType,
+                        companyId: ctx.sessionInfo.companyID,
+                    },
+                    seqId: Number(ctx.messageId),
+                    maxBytes,
+                });
+                log(`[${accountId}]: resolved ${mediaInfos.length} media, paths=${mediaInfos.map(m => m.path).join(",")}`);
+                mediaPaths = mediaInfos.map((m) => m.path);
+                if (mediaInfos.length > 0) {
+                    // 为 BodyForAgent 生成详细媒体描述（包含路径）
+                    mediaContext = "\n\n" + mediaInfos.map((m) => {
+                        const typeLabel = m.contentType?.startsWith("image/") ? "<media:image>"
+                            : m.contentType?.startsWith("video/") ? "<media:video>"
+                                : m.contentType?.startsWith("audio/") ? "<media:audio>"
+                                    : "<media:document>";
+                        return `${typeLabel}: ${m.path}`;
+                    }).join("\n");
+                }
+            }
+            catch (err) {
+                error(`[${accountId}]: failed to resolve media: ${String(err)}`);
+            }
+        }
+        // 处理引用消息的媒体附件
+        if (quoteMsgMap && ctx.replyContext) {
+            const quoteMedia = extractQuoteMessageMedia(msg, quoteMsgMap);
+            if (quoteMedia && quoteMedia.length > 0) {
+                log(`[${accountId}]: processing ${quoteMedia.length} quote message media attachment(s)`);
+                try {
+                    const maxBytes = meetCfg.mediaMaxMb ? meetCfg.mediaMaxMb * 1024 * 1024 : undefined;
+                    const quoteMediaInfos = await resolveMediaAttachments({
+                        accountId,
+                        attachments: quoteMedia,
+                        sessionInfo: {
+                            firstId: ctx.sessionInfo.firstID,
+                            secondId: ctx.sessionInfo.secondID,
+                            sessionType: ctx.sessionInfo.sessionType,
+                            companyId: ctx.sessionInfo.companyID,
+                        },
+                        seqId: Number(ctx.replyContext.messageId),
+                        maxBytes,
+                    });
+                    log(`[${accountId}]: resolved ${quoteMediaInfos.length} quote media, paths=${quoteMediaInfos.map(m => m.path).join(",")}`);
+                    // 将引用消息的媒体路径合并到 mediaPaths
+                    mediaPaths = [...mediaPaths, ...quoteMediaInfos.map((m) => m.path)];
+                }
+                catch (err) {
+                    error(`[${accountId}]: failed to resolve quote media: ${String(err)}`);
+                }
+            }
+        }
+        // 构建最终的消息内容
+        // Discord 做法：文字优先，无文字时用媒体占位符
+        // 媒体路径通过 MediaPaths 传递，mediaContext 仅作为 BodyForAgent 的补充描述
+        const finalContent = ctx.content.trim()
+            ? `${ctx.content.trim()}${mediaContext}`
+            : (ctx.placeholder || "") + mediaContext;
+        // Discord 做法：跳过空内容消息
+        if (!finalContent.trim() && mediaPaths.length === 0) {
+            log(`[${accountId}]: skip message ${ctx.messageId} (empty content)`);
+            return;
+        }
+        const preview = finalContent.replace(/\s+/g, " ").slice(0, 160);
+        const inboundLabel = isGroup
+            ? `Meet[${accountId}] message in group ${ctx.chatId}`
+            : `Meet[${accountId}] DM from ${ctx.senderId}`;
+        core.system.enqueueSystemEvent(`${inboundLabel}: ${preview}`, {
+            sessionKey: route.sessionKey,
+            contextKey: `meet:message:${ctx.chatId}:${ctx.messageId}`,
+        });
+        const envelopeFrom = isGroup ? `${ctx.chatId}:${ctx.senderId}` : ctx.senderId;
+        const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+        // 将当前消息添加到历史（在确认要处理消息之后）
+        const historyEntries = isGroup && historyLimit > 0
+            ? (() => {
+                const entries = groupHistories.get(ctx.chatId) ?? [];
+                entries.push(pendingEntry);
+                while (entries.length > historyLimit) {
+                    entries.shift();
+                }
+                groupHistories.set(ctx.chatId, entries);
+                return entries;
+            })()
+            : [];
+        const bodyWithContext = buildPendingHistoryContextFromMap({
+            historyMap: groupHistories,
+            historyKey: ctx.chatId,
+            limit: historyLimit,
+            currentMessage: messageBody,
+            formatEntry: formatHistoryEntry,
+        });
+        const body = core.channel.reply.formatAgentEnvelope({
+            channel: "Meet",
+            from: envelopeFrom,
+            timestamp: new Date(),
+            envelope: envelopeOptions,
+            body: bodyWithContext,
+        });
+        const inboundHistory = isGroup && historyLimit > 0
+            ? historyEntries.map((entry) => ({
+                sender: entry.sender,
+                body: entry.body,
+                timestamp: entry.timestamp,
+            }))
+            : undefined;
+        const channelConfig = isGroup ? meetCfg.channels?.[ctx.chatId] : undefined;
+        const groupConfig = isGroup ? resolveMeetGroupConfig({ meetConfig: meetCfg, chatId: ctx.chatId }) : undefined;
+        const systemPrompt = isGroup
+            ? (groupConfig?.systemPrompt ?? channelConfig?.systemPrompt ?? meetCfg.systemPrompt ?? DEFAULT_GROUP_SYSTEM_PROMPT)
+            : (meetCfg.systemPrompt ?? DEFAULT_DM_SYSTEM_PROMPT);
+        const inboundCtx = core.channel.reply.finalizeInboundContext({
+            Body: body,
+            BodyForAgent: finalContent,
+            RawBody: ctx.content,
+            CommandBody: ctx.content,
+            From: meetFrom,
+            To: meetTo,
+            SessionKey: route.sessionKey,
+            AccountId: route.accountId,
+            ChatType: isGroup ? "group" : "direct",
+            GroupSubject: isGroup ? ctx.chatId : undefined,
+            GroupSystemPrompt: systemPrompt,
+            SenderName: ctx.senderName,
+            SenderId: ctx.senderId,
+            Provider: "meet",
+            Surface: "meet",
+            MessageSid: ctx.messageId,
+            Timestamp: ctx.timestamp ?? Date.now(),
+            WasMentioned: ctx.mentionedBot,
+            ReplyToId: ctx.replyContext?.messageId,
+            ReplyToBody: ctx.replyContext?.content,
+            ReplyToSender: ctx.replyContext?.senderId,
+            InboundHistory: inboundHistory,
+            CommandAuthorized: true,
+            OriginatingChannel: "meet",
+            OriginatingTo: meetTo,
+            MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+        });
+        const { createMeetReplyDispatcher } = await import("./reply-dispatcher.js");
+        const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
+        const { dispatcher, replyOptions, markDispatchIdle, markRunComplete } = await createMeetReplyDispatcher({
+            cfg,
+            agentId: route.agentId,
+            runtime: runtime,
+            chatId: ctx.chatId,
+            replyToMessageId: ctx.messageId,
+            accountId,
+            bot,
+            botUserId,
+            mediaLocalRoots,
+        });
+        log(`[${accountId}]: dispatching to AI agent=${route.agentId} session=${route.sessionKey} history=${inboundHistory?.length ?? 0}`);
+        const dispatchResult = await core.channel.reply.dispatchReplyFromConfig({
+            ctx: inboundCtx,
+            cfg,
+            dispatcher,
+            replyOptions,
+        });
+        log(`[${accountId}]: dispatch result queuedFinal=${String(dispatchResult.queuedFinal)} counts=${JSON.stringify(dispatchResult.counts)} failedCounts=${JSON.stringify(dispatchResult.failedCounts ?? {})} sourceReplyDeliveryMode=${dispatchResult.sourceReplyDeliveryMode ?? "default"}`);
+        log(`[${accountId}]: AI response completed for message ${ctx.messageId}`);
+        markRunComplete();
+        markDispatchIdle();
+        clearHistoryEntriesIfEnabled({
+            historyMap: groupHistories,
+            historyKey: ctx.chatId,
+            limit: historyLimit,
+        });
+    }
+    catch (err) {
+        error(`[${accountId}]: error processing message: ${String(err)}`);
+    }
+}

package/dist/src/channel.d.ts

@@ -0,0 +1,3 @@
+import type { ChannelPlugin } from "openclaw/plugin-sdk";
+import type { ResolvedMeetAccount } from "./types.js";
+export declare const meetPlugin: ChannelPlugin<ResolvedMeetAccount>;