@meet-im/meet 3.4.5 → 3.6.0

package/dist/src/approval-native.d.ts

@@ -0,0 +1,30 @@
+import { type ChannelApprovalNativeRuntimeAdapter } from "openclaw/plugin-sdk/approval-handler-runtime";
+import type { ChannelApprovalCapability } from "openclaw/plugin-sdk/channel-contract";
+import type { MeetExecApprovalConfig } from "./types.js";
+type MeetPendingPayload = {
+    text: string;
+};
+type MeetPreparedTarget = {
+    to: string;
+    threadId?: string;
+};
+type MeetPendingEntry = {
+    chatId: string;
+    messageId: string;
+};
+export declare const meetApprovalNativeRuntime: ChannelApprovalNativeRuntimeAdapter<MeetPendingPayload, MeetPreparedTarget, MeetPendingEntry, never, unknown>;
+export declare function createMeetNativeApprovalAdapter(configOverride?: MeetExecApprovalConfig | null): {
+    auth: {
+        authorizeActorAction?: ChannelApprovalCapability["authorizeActorAction"];
+        getActionAvailabilityState?: ChannelApprovalCapability["getActionAvailabilityState"];
+        getExecInitiatingSurfaceState?: ChannelApprovalCapability["getExecInitiatingSurfaceState"];
+        resolveApproveCommandBehavior?: ChannelApprovalCapability["resolveApproveCommandBehavior"];
+    };
+    delivery: ChannelApprovalCapability["delivery"];
+    nativeRuntime: ChannelApprovalCapability["nativeRuntime"];
+    render: ChannelApprovalCapability["render"];
+    native: ChannelApprovalCapability["native"];
+    describeExecApprovalSetup: ChannelApprovalCapability["describeExecApprovalSetup"];
+};
+export declare function getMeetApprovalCapability(): ChannelApprovalCapability;
+export {};

package/dist/src/approval-native.js

@@ -0,0 +1,260 @@
+import { createChannelApprovalNativeRuntimeAdapter, } from "openclaw/plugin-sdk/approval-handler-runtime";
+import { buildChannelApprovalNativeTargetKey, resolveApprovalRequestSessionConversation, } from "openclaw/plugin-sdk/approval-native-runtime";
+import { buildExecApprovalPendingReplyPayload, } from "openclaw/plugin-sdk/approval-runtime";
+import { normalizeLowercaseStringOrEmpty, normalizeOptionalString, } from "openclaw/plugin-sdk/string-coerce-runtime";
+import { listMeetAccountIds, resolveMeetAccount } from "./accounts.js";
+import { createChannelApproverDmTargetResolver, createChannelNativeOriginTargetResolver, createApproverRestrictedNativeApprovalCapability, splitChannelApprovalCapability, } from "openclaw/plugin-sdk/approval-runtime";
+import { getMeetExecApprovalApprovers, isMeetExecApprovalApprover, isMeetExecApprovalClientEnabled, } from "./exec-approvals.js";
+import { encodeMeetDmTopicId } from "./dm-topic-codec.js";
+import { sendMessageMeet } from "./send.js";
+function shouldHandleMeetApprovalRequest(_params) {
+    return true;
+}
+function extractMeetSessionKind(sessionKey) {
+    if (!sessionKey) {
+        return null;
+    }
+    const match = sessionKey.match(/meet:(channel|group|dm):/);
+    if (!match) {
+        return null;
+    }
+    return match[1];
+}
+function normalizeMeetOriginChannelId(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const prefixed = trimmed.match(/^(?:channel):(-?\d+)$/i);
+    if (prefixed) {
+        return prefixed[1];
+    }
+    return /^-?\d+$/.test(trimmed) ? trimmed : null;
+}
+function normalizeMeetOriginTarget(value) {
+    if (!value) {
+        return null;
+    }
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return null;
+    }
+    const prefixed = trimmed.match(/^(?:channel|user):(-?\d+)$/i);
+    if (prefixed) {
+        const kind = trimmed.toLowerCase().startsWith("user:") ? "user" : "channel";
+        return `${kind}:${prefixed[1]}`;
+    }
+    return /^-?\d+$/.test(trimmed) ? trimmed : null;
+}
+function normalizeMeetThreadId(value) {
+    if (typeof value === "number") {
+        return Number.isFinite(value) ? String(value) : undefined;
+    }
+    if (typeof value !== "string") {
+        return undefined;
+    }
+    const normalized = value.trim();
+    return normalized || undefined;
+}
+function createMeetOriginTargetResolver(_configOverride) {
+    return createChannelNativeOriginTargetResolver({
+        channel: "meet",
+        shouldHandleRequest: ({ cfg, accountId, request }) => shouldHandleMeetApprovalRequest({
+            cfg,
+            accountId,
+            request,
+        }),
+        resolveTurnSourceTarget: (request) => {
+            const sessionConversation = resolveApprovalRequestSessionConversation({
+                request,
+                channel: "meet",
+                bundledFallback: false,
+            });
+            const sessionKind = extractMeetSessionKind(normalizeOptionalString(request.request.sessionKey) ?? null);
+            const turnSourceChannel = normalizeLowercaseStringOrEmpty(request.request.turnSourceChannel);
+            const rawTurnSourceTo = normalizeOptionalString(request.request.turnSourceTo) ?? "";
+            const turnSourceTarget = normalizeMeetOriginTarget(rawTurnSourceTo);
+            const turnSourceTo = normalizeMeetOriginChannelId(rawTurnSourceTo);
+            const threadId = encodeMeetDmTopicId(normalizeMeetThreadId(request.request.turnSourceThreadId)) ??
+                normalizeMeetThreadId(sessionConversation?.threadId) ??
+                undefined;
+            const hasExplicitOriginTarget = /^(?:channel):/i.test(rawTurnSourceTo);
+            if (turnSourceChannel !== "meet") {
+                return null;
+            }
+            if (sessionKind === "dm") {
+                return turnSourceTarget && /^user:/i.test(turnSourceTarget)
+                    ? { to: turnSourceTarget, threadId }
+                    : null;
+            }
+            if (!turnSourceTo) {
+                return null;
+            }
+            return hasExplicitOriginTarget || sessionKind === "channel" || sessionKind === "group"
+                ? { to: turnSourceTo, threadId }
+                : null;
+        },
+        resolveSessionTarget: (sessionTarget, request) => {
+            const sessionConversation = resolveApprovalRequestSessionConversation({
+                request,
+                channel: "meet",
+                bundledFallback: false,
+            });
+            const sessionKind = extractMeetSessionKind(request.request.sessionKey?.trim() || null);
+            if (sessionKind === "dm") {
+                return null;
+            }
+            const targetTo = normalizeMeetOriginChannelId(sessionTarget.to);
+            return targetTo
+                ? {
+                    to: targetTo,
+                    threadId: normalizeMeetThreadId(sessionTarget.threadId) ??
+                        normalizeMeetThreadId(sessionConversation?.threadId) ??
+                        undefined,
+                }
+                : null;
+        },
+        resolveFallbackTarget: (request) => {
+            const sessionConversation = resolveApprovalRequestSessionConversation({
+                request,
+                channel: "meet",
+                bundledFallback: false,
+            });
+            const sessionKind = extractMeetSessionKind(request.request.sessionKey?.trim() || null);
+            if (sessionKind === "dm") {
+                return null;
+            }
+            const fallbackChannelId = normalizeMeetOriginChannelId(sessionConversation?.id);
+            return fallbackChannelId
+                ? {
+                    to: fallbackChannelId,
+                    threadId: normalizeMeetThreadId(sessionConversation?.threadId) ?? undefined,
+                }
+                : null;
+        },
+    });
+}
+function createMeetApproverDmTargetResolver(configOverride) {
+    return createChannelApproverDmTargetResolver({
+        shouldHandleRequest: ({ cfg, accountId, request }) => shouldHandleMeetApprovalRequest({
+            cfg,
+            accountId,
+            request,
+        }),
+        resolveApprovers: ({ cfg, accountId }) => getMeetExecApprovalApprovers({ cfg, accountId, configOverride }),
+        mapApprover: (approver) => ({ to: `user:${approver}` }),
+    });
+}
+function buildMeetPendingPayload(params) {
+    if (params.view.approvalKind !== "exec") {
+        return {
+            text: params.view.title,
+        };
+    }
+    const payload = buildExecApprovalPendingReplyPayload({
+        approvalId: params.request.id,
+        approvalSlug: params.request.id.slice(0, 8),
+        approvalCommandId: params.request.id,
+        warningText: params.view.warningText ?? normalizeOptionalString(params.request.request.warningText) ?? undefined,
+        ask: params.view.ask ?? normalizeOptionalString(params.request.request.ask) ?? undefined,
+        agentId: params.view.agentId ?? normalizeOptionalString(params.request.request.agentId) ?? undefined,
+        allowedDecisions: params.view.actions.map((action) => action.decision),
+        command: params.view.commandText,
+        cwd: params.view.cwd ?? normalizeOptionalString(params.request.request.cwd) ?? undefined,
+        host: params.view.host === "node" ? "node" : "gateway",
+        nodeId: params.view.nodeId ?? normalizeOptionalString(params.request.request.nodeId) ?? undefined,
+        sessionKey: params.view.sessionKey ?? normalizeOptionalString(params.request.request.sessionKey) ?? undefined,
+        expiresAtMs: params.request.expiresAtMs,
+        nowMs: params.nowMs,
+    });
+    const reason = params.view.ask?.trim();
+    const text = reason ? `${reason}\n\n${payload.text ?? ""}` : (payload.text ?? "");
+    return {
+        text,
+    };
+}
+export const meetApprovalNativeRuntime = createChannelApprovalNativeRuntimeAdapter({
+    eventKinds: ["exec", "plugin"],
+    availability: {
+        isConfigured: ({ cfg, accountId }) => isMeetExecApprovalClientEnabled({ cfg, accountId }),
+        shouldHandle: ({ cfg, accountId, request }) => shouldHandleMeetApprovalRequest({
+            cfg,
+            accountId,
+            request,
+        }),
+    },
+    presentation: {
+        buildPendingPayload: ({ request, nowMs, view }) => buildMeetPendingPayload({
+            request: request,
+            nowMs,
+            view,
+        }),
+        buildResolvedResult: () => ({ kind: "leave" }),
+        buildExpiredResult: () => ({ kind: "leave" }),
+    },
+    transport: {
+        prepareTarget: ({ plannedTarget }) => ({
+            dedupeKey: buildChannelApprovalNativeTargetKey(plannedTarget.target),
+            target: {
+                to: plannedTarget.surface === "approver-dm" && !/^user:/i.test(plannedTarget.target.to)
+                    ? `user:${plannedTarget.target.to}`
+                    : plannedTarget.target.to,
+                ...(plannedTarget.target.threadId != null
+                    ? { threadId: String(plannedTarget.target.threadId) }
+                    : {}),
+            },
+        }),
+        deliverPending: async ({ cfg, accountId, preparedTarget, pendingPayload }) => {
+            try {
+                const result = await sendMessageMeet({
+                    cfg: cfg,
+                    to: preparedTarget.to,
+                    text: pendingPayload.text,
+                    accountId: accountId ?? undefined,
+                    threadId: preparedTarget.threadId,
+                });
+                return {
+                    chatId: result.chatId,
+                    messageId: result.messageId,
+                };
+            }
+            catch {
+                return null;
+            }
+        },
+    },
+});
+function createMeetApprovalCapability(configOverride) {
+    return createApproverRestrictedNativeApprovalCapability({
+        channel: "meet",
+        channelLabel: "Meet",
+        describeExecApprovalSetup: ({ accountId, }) => {
+            const prefix = accountId && accountId !== "default"
+                ? `channels.meet.accounts.${accountId}`
+                : "channels.meet";
+            return `Approve it from the Web UI or terminal UI for now. Meet supports native exec approvals for this account. Configure \`${prefix}.execApprovals.approvers\` or \`commands.ownerAllowFrom\`; set \`${prefix}.execApprovals.enabled\` to \`auto\` or \`true\`.`;
+        },
+        listAccountIds: listMeetAccountIds,
+        hasApprovers: ({ cfg, accountId }) => getMeetExecApprovalApprovers({ cfg, accountId, configOverride }).length > 0,
+        isExecAuthorizedSender: ({ cfg, accountId, senderId }) => isMeetExecApprovalApprover({ cfg, accountId, senderId, configOverride }),
+        isNativeDeliveryEnabled: ({ cfg, accountId }) => isMeetExecApprovalClientEnabled({ cfg, accountId, configOverride }),
+        resolveNativeDeliveryMode: ({ cfg, accountId }) => configOverride?.target ??
+            resolveMeetAccount({ cfg, accountId }).config.execApprovals?.target ??
+            "dm",
+        resolveOriginTarget: createMeetOriginTargetResolver(configOverride),
+        resolveApproverDmTargets: createMeetApproverDmTargetResolver(configOverride),
+        notifyOriginWhenDmOnly: true,
+        nativeRuntime: meetApprovalNativeRuntime,
+    });
+}
+export function createMeetNativeApprovalAdapter(configOverride) {
+    return splitChannelApprovalCapability(createMeetApprovalCapability(configOverride));
+}
+let cachedMeetApprovalCapability;
+export function getMeetApprovalCapability() {
+    cachedMeetApprovalCapability ??= createMeetApprovalCapability();
+    return cachedMeetApprovalCapability;
+}

package/dist/src/bot.js

@@ -2,7 +2,8 @@ import { buildPendingHistoryContextFromMap, clearHistoryEntriesIfEnabled, record
 import { buildChannelInboundEventContext } from "openclaw/plugin-sdk/channel-inbound";
 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 { msgContentToContext, extractQuoteMessageMedia, parseMergedForwardContent } from "./sdk-bridge.js";
+import { buildMeetRoutePeerId } from "./route-peer.js";
 import { getMeetRuntime } from "./runtime.js";
 import { resolveMeetAllowlistMatch, resolveMeetGroupPolicy, resolveMeetGroupConfig, resolveMeetGroupUserPolicy } from "./policy.js";
 import { sendMessageMeet } from "./send.js";
@@ -12,6 +13,9 @@ const DEFAULT_DM_SYSTEM_PROMPT = "你正在 Meet 私聊中对话。注意：Meet
 function formatHistoryEntry(entry) {
     return `${entry.sender}: ${entry.body}`;
 }
+function isSessionBoundaryCommand(text) {
+    return /^\/(?:new|reset)(?:\s|$)/i.test(text.trim());
+}
 export async function handleMeetMessage(params) {
     const { cfg, msg, botUserId, runtime, accountId, account, bot, groupHistories, quoteMsgMap, ctx: providedCtx } = params;
     const log = runtime?.log ?? console.log;
@@ -36,11 +40,10 @@ export async function handleMeetMessage(params) {
     const historyLimit = isGroup
         ? Math.max(0, meetCfg.historyLimit ?? cfg.messages?.groupChat?.historyLimit ?? 20)
         : Math.max(0, meetCfg.dmHistoryLimit ?? 0);
+    const historyKey = isGroup
+        ? ctx.chatId
+        : (ctx.threadId ? `${ctx.chatId}__topic__${ctx.threadId}` : ctx.chatId);
     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 || "",
@@ -149,16 +152,48 @@ export async function handleMeetMessage(params) {
                 log(`[${accountId}]: message in group ${ctx.chatId} skipped (mention required)`);
                 recordPendingHistoryEntryIfEnabled({
                     historyMap: groupHistories,
-                    historyKey: ctx.chatId,
+                    historyKey,
                     entry: pendingEntry,
                     limit: historyLimit,
                 });
                 return;
             }
         }
+        // 合并转发消息(msgType=19)：只进上下文，不发给 LLM
+        const msgType = Number(msg.extraInfo?.msgType);
+        if (msgType === 19) {
+            log(`[${accountId}]: skipping merged forward message ${ctx.messageId} (msgType=19, context only)`);
+            if (historyLimit > 0) {
+                const subEntries = parseMergedForwardContent(msg.content ?? "");
+                const entries = groupHistories.get(historyKey) ?? [];
+                if (subEntries.length > 0) {
+                    for (const sub of subEntries) {
+                        entries.push({
+                            sender: sub.sender,
+                            body: sub.body,
+                            timestamp: sub.timestamp,
+                            messageId: sub.messageId,
+                        });
+                    }
+                }
+                else {
+                    entries.push(pendingEntry);
+                }
+                while (entries.length > historyLimit) {
+                    entries.shift();
+                }
+                groupHistories.set(historyKey, entries);
+            }
+            return;
+        }
         const meetFrom = `meet:${ctx.senderId}`;
         const meetTo = ctx.chatId;
-        const peerId = isGroup ? ctx.chatId : ctx.senderId;
+        const peerId = buildMeetRoutePeerId({
+            isGroup,
+            senderId: ctx.senderId,
+            chatId: ctx.chatId,
+            threadId: ctx.threadId,
+        });
         const route = core.channel.routing.resolveAgentRoute({
             cfg,
             channel: "meet",
@@ -167,6 +202,7 @@ export async function handleMeetMessage(params) {
                 kind: isGroup ? "group" : "direct",
                 id: peerId,
             },
+            ...(ctx.threadId ? { threadId: ctx.threadId } : {}),
         });
         // 处理媒体附件
         let mediaContext = "";
@@ -257,6 +293,9 @@ export async function handleMeetMessage(params) {
             ? ctx.content.trim()
             : (ctx.placeholder || "");
         const finalContent = `${quoteContext}${userBody}${mentionsContext}${mediaContext}`;
+        if (isSessionBoundaryCommand(ctx.rawBody ?? ctx.content)) {
+            groupHistories.set(historyKey, []);
+        }
         // Discord 做法：跳过空内容消息
         if (!finalContent.trim() && mediaPaths.length === 0) {
             log(`[${accountId}]: skip message ${ctx.messageId} (empty content)`);
@@ -273,22 +312,22 @@ export async function handleMeetMessage(params) {
         const envelopeFrom = isGroup ? `${ctx.chatId}:${ctx.senderId}` : ctx.senderId;
         const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
         // 将当前消息添加到历史（在确认要处理消息之后）
-        const historyEntries = isGroup && historyLimit > 0
+        const historyEntries = historyLimit > 0
             ? (() => {
-                const entries = groupHistories.get(ctx.chatId) ?? [];
+                const entries = groupHistories.get(historyKey) ?? [];
                 entries.push(pendingEntry);
                 while (entries.length > historyLimit) {
                     entries.shift();
                 }
-                groupHistories.set(ctx.chatId, entries);
+                groupHistories.set(historyKey, entries);
                 return entries;
             })()
             : [];
         const bodyWithContext = buildPendingHistoryContextFromMap({
             historyMap: groupHistories,
-            historyKey: ctx.chatId,
+            historyKey,
             limit: historyLimit,
-            currentMessage: messageBody,
+            currentMessage: finalContent,
             formatEntry: formatHistoryEntry,
         });
         const body = core.channel.reply.formatAgentEnvelope({
@@ -298,7 +337,7 @@ export async function handleMeetMessage(params) {
             envelope: envelopeOptions,
             body: bodyWithContext,
         });
-        const inboundHistory = isGroup && historyLimit > 0
+        const inboundHistory = historyLimit > 0
             ? historyEntries.map((entry) => ({
                 sender: entry.sender,
                 body: entry.body,
@@ -326,6 +365,7 @@ export async function handleMeetMessage(params) {
                 kind: isGroup ? "group" : "direct",
                 id: ctx.chatId,
                 label: isGroup ? (groupConfig?.groupConfig?.name ?? ctx.chatId) : ctx.chatId,
+                ...(ctx.threadId ? { threadId: ctx.threadId } : {}),
                 routePeer: {
                     kind: isGroup ? "group" : "direct",
                     id: peerId,
@@ -339,11 +379,12 @@ export async function handleMeetMessage(params) {
             reply: {
                 to: meetTo,
                 originatingTo: meetTo,
+                ...(ctx.threadId ? { messageThreadId: ctx.threadId } : {}),
             },
             message: {
                 body,
                 rawBody: ctx.content,
-                bodyForAgent: finalContent,
+                bodyForAgent: bodyWithContext,
                 commandBody: ctx.rawBody ?? ctx.content,
                 envelopeFrom,
                 inboundHistory,
@@ -389,6 +430,7 @@ export async function handleMeetMessage(params) {
             agentId: route.agentId,
             runtime: runtime,
             chatId: ctx.chatId,
+            threadId: ctx.threadId,
             senderId: ctx.senderId,
             mentionedBot: ctx.mentionedBot,
             replyToMessageId: ctx.messageId,
@@ -402,7 +444,7 @@ export async function handleMeetMessage(params) {
             apiEndpoint: account.apiEndpoint,
             typingMode: effectiveTypingMode,
         });
-        log(`[${accountId}]: dispatch ctx replyToId=${inboundCtx.ReplyToId ?? "undefined"} replyToBody=${JSON.stringify(inboundCtx.ReplyToBody ?? "")} rawBody=${JSON.stringify(inboundCtx.RawBody ?? "")} commandBody=${JSON.stringify(inboundCtx.CommandBody ?? "")} bodyForAgent=${JSON.stringify(inboundCtx.BodyForAgent ?? "")}`);
+        log(`[${accountId}]: dispatch ctx historyKey=${historyKey} routeSessionKey=${route.sessionKey} replyToId=${inboundCtx.ReplyToId ?? "undefined"} replyToBody=${JSON.stringify(inboundCtx.ReplyToBody ?? "")} rawBody=${JSON.stringify(inboundCtx.RawBody ?? "")} commandBody=${JSON.stringify(inboundCtx.CommandBody ?? "")} bodyForAgent=${JSON.stringify(inboundCtx.BodyForAgent ?? "")}`);
         log(`[${accountId}]: dispatching to AI agent=${route.agentId} session=${route.sessionKey} history=${inboundHistory?.length ?? 0}`);
         const dispatchResult = await core.channel.reply.dispatchReplyFromConfig({
             ctx: inboundCtx,
@@ -414,11 +456,13 @@ export async function handleMeetMessage(params) {
         log(`[${accountId}]: AI response completed for message ${ctx.messageId}`);
         markRunComplete();
         markDispatchIdle();
-        clearHistoryEntriesIfEnabled({
-            historyMap: groupHistories,
-            historyKey: ctx.chatId,
-            limit: historyLimit,
-        });
+        if (isGroup) {
+            clearHistoryEntriesIfEnabled({
+                historyMap: groupHistories,
+                historyKey,
+                limit: historyLimit,
+            });
+        }
     }
     catch (err) {
         error(`[${accountId}]: error processing message: ${String(err)}`);

package/dist/src/channel.js

@@ -7,6 +7,7 @@ import { sendMessageMeet } from "./send.js";
 import { getMeetClient } from "./client.js";
 import { getAllCachedUsers, rememberMeetUser } from "./directory-cache.js";
 import { MeetPluginConfigSchema } from "./config-schema.js";
+import { getMeetApprovalCapability } from "./approval-native.js";
 const meta = {
     id: "meet",
     label: "Meet",
@@ -298,6 +299,7 @@ export const meetPlugin = {
         listGroupsLive: async () => [],
     },
     outbound: meetOutbound,
+    approvalCapability: getMeetApprovalCapability(),
     status: {
         defaultRuntime: {
             accountId: DEFAULT_ACCOUNT_ID,

package/dist/src/client.js

@@ -39,7 +39,6 @@ export function createMeetClient(account) {
         pollingLimit: account.config.pollLimit ?? POLLING.DEFAULT_LIMIT,
         longPollingTimeout: pollTimeoutSec,
         logLevel,
-        useV2: true,
         userAgent: buildUserAgent(),
     });
     botInstances.set(account.accountId, bot);

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

@@ -16,6 +16,17 @@ export declare const MeetGroupConfigSchema: z.ZodObject<{
         disabled: "disabled";
     }>>;
 }, z.core.$strip>;
+export declare const MeetExecApprovalConfigSchema: z.ZodObject<{
+    enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+    approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    target: z.ZodOptional<z.ZodEnum<{
+        dm: "dm";
+        channel: "channel";
+        both: "both";
+    }>>;
+    agentFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    sessionFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+}, z.core.$strip>;
 export declare const MeetAccountConfigSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
     name: z.ZodOptional<z.ZodString>;
@@ -63,6 +74,17 @@ export declare const MeetAccountConfigSchema: z.ZodObject<{
             disabled: "disabled";
         }>>;
     }, z.core.$strip>>>;
+    execApprovals: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+        approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        target: z.ZodOptional<z.ZodEnum<{
+            dm: "dm";
+            channel: "channel";
+            both: "both";
+        }>>;
+        agentFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sessionFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const MeetConfigSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
@@ -163,6 +185,28 @@ export declare const MeetConfigSchema: z.ZodObject<{
                 disabled: "disabled";
             }>>;
         }, z.core.$strip>>>;
+        execApprovals: z.ZodOptional<z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+            approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+            target: z.ZodOptional<z.ZodEnum<{
+                dm: "dm";
+                channel: "channel";
+                both: "both";
+            }>>;
+            agentFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+            sessionFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        }, z.core.$strip>>;
     }, z.core.$strip>>>;
+    execApprovals: z.ZodOptional<z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodUnion<readonly [z.ZodBoolean, z.ZodLiteral<"auto">]>>;
+        approvers: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        target: z.ZodOptional<z.ZodEnum<{
+            dm: "dm";
+            channel: "channel";
+            both: "both";
+        }>>;
+        agentFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+        sessionFilter: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
 }, z.core.$strip>;
 export declare const MeetPluginConfigSchema: import("openclaw/plugin-sdk").ChannelConfigSchema;

package/dist/src/config-schema.js

@@ -13,6 +13,13 @@ export const MeetGroupConfigSchema = z.object({
     users: z.array(z.union([z.string(), z.number()])).optional(),
     groupPolicy: z.enum(["open", "allowlist", "disabled"]).optional(),
 });
+export const MeetExecApprovalConfigSchema = z.object({
+    enabled: z.union([z.boolean(), z.literal("auto")]).optional(),
+    approvers: z.array(z.union([z.string(), z.number()])).optional(),
+    target: z.enum(["dm", "channel", "both"]).optional(),
+    agentFilter: z.array(z.string()).optional(),
+    sessionFilter: z.array(z.string()).optional(),
+});
 export const MeetAccountConfigSchema = z.object({
     enabled: z.boolean().optional(),
     name: z.string().optional(),
@@ -34,6 +41,7 @@ export const MeetAccountConfigSchema = z.object({
     mediaMaxMb: z.number().min(0).optional(),
     typingMode: z.enum(["none", "instant", "message"]).optional(),
     groups: z.record(z.string(), MeetGroupConfigSchema).optional(),
+    execApprovals: MeetExecApprovalConfigSchema.optional(),
 });
 export const MeetConfigSchema = z.object({
     enabled: z.boolean().optional(),
@@ -58,5 +66,6 @@ export const MeetConfigSchema = z.object({
     mediaMaxMb: z.number().min(0).optional(),
     typingMode: z.enum(["none", "instant", "message"]).optional(),
     accounts: z.record(z.string(), MeetAccountConfigSchema).optional(),
+    execApprovals: MeetExecApprovalConfigSchema.optional(),
 });
 export const MeetPluginConfigSchema = buildChannelConfigSchema(MeetConfigSchema);

package/dist/src/dm-topic-codec.d.ts

@@ -0,0 +1,4 @@
+export declare const MEET_DM_TOPIC_THREAD_PREFIX = "meetdm_b64_";
+export declare function isEncodedMeetDmTopicThreadId(threadId?: string | null): boolean;
+export declare function encodeMeetDmTopicId(raw?: string | null): string | undefined;
+export declare function decodeMeetDmTopicThreadId(threadId?: string | null): string | undefined;

package/dist/src/dm-topic-codec.js

@@ -0,0 +1,33 @@
+export const MEET_DM_TOPIC_THREAD_PREFIX = "meetdm_b64_";
+function normalizeNonEmpty(value) {
+    const trimmed = value?.trim();
+    return trimmed ? trimmed : undefined;
+}
+function toBase64Url(input) {
+    return Buffer.from(input, "utf8")
+        .toString("base64")
+        .replace(/\+/g, "-")
+        .replace(/\//g, "_")
+        .replace(/=+$/g, "");
+}
+function fromBase64Url(input) {
+    const base64 = input.replace(/-/g, "+").replace(/_/g, "/");
+    const padded = base64 + "=".repeat((4 - (base64.length % 4)) % 4);
+    return Buffer.from(padded, "base64").toString("utf8");
+}
+export function isEncodedMeetDmTopicThreadId(threadId) {
+    const normalized = normalizeNonEmpty(threadId);
+    return normalized?.startsWith(MEET_DM_TOPIC_THREAD_PREFIX) ?? false;
+}
+export function encodeMeetDmTopicId(raw) {
+    const normalized = normalizeNonEmpty(raw);
+    return normalized ? `${MEET_DM_TOPIC_THREAD_PREFIX}${toBase64Url(normalized)}` : undefined;
+}
+export function decodeMeetDmTopicThreadId(threadId) {
+    const normalized = normalizeNonEmpty(threadId);
+    if (!normalized)
+        return undefined;
+    if (!normalized.startsWith(MEET_DM_TOPIC_THREAD_PREFIX))
+        return normalized;
+    return fromBase64Url(normalized.slice(MEET_DM_TOPIC_THREAD_PREFIX.length));
+}

package/dist/src/exec-approvals.d.ts

@@ -0,0 +1,26 @@
+import type { ChannelOutboundPayloadHint } from "openclaw/plugin-sdk/channel-contract";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/config-contracts";
+import type { ReplyPayload } from "openclaw/plugin-sdk/reply-dispatch-runtime";
+import type { MeetExecApprovalConfig } from "./types.js";
+export declare function getMeetExecApprovalApprovers(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    configOverride?: MeetExecApprovalConfig | null;
+}): string[];
+export declare function isMeetExecApprovalClientEnabled(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    configOverride?: MeetExecApprovalConfig | null;
+}): boolean;
+export declare function isMeetExecApprovalApprover(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    senderId?: string | null;
+    configOverride?: MeetExecApprovalConfig | null;
+}): boolean;
+export declare function shouldSuppressLocalMeetExecApprovalPrompt(params: {
+    cfg: OpenClawConfig;
+    accountId?: string | null;
+    payload: ReplyPayload;
+    hint?: ChannelOutboundPayloadHint;
+}): boolean;

package/dist/src/exec-approvals.js

@@ -0,0 +1,71 @@
+import { resolveMeetAccount } from "./accounts.js";
+import { getExecApprovalReplyMetadata, isChannelExecApprovalClientEnabledFromConfig, matchesApprovalRequestFilters, resolveApprovalApprovers, } from "openclaw/plugin-sdk/approval-runtime";
+function normalizeMeetApproverId(value) {
+    const trimmed = value.trim();
+    if (!trimmed) {
+        return undefined;
+    }
+    // Meet 用户ID是数字
+    if (/^-?\d+$/.test(trimmed)) {
+        return trimmed;
+    }
+    // 支持 user:ID 格式
+    const match = trimmed.match(/^user:(-?\d+)$/i);
+    return match ? match[1] : undefined;
+}
+function resolveMeetOwnerApprovers(cfg) {
+    const ownerAllowFrom = cfg.commands?.ownerAllowFrom;
+    if (!Array.isArray(ownerAllowFrom) || ownerAllowFrom.length === 0) {
+        return [];
+    }
+    return resolveApprovalApprovers({
+        explicit: ownerAllowFrom,
+        normalizeApprover: (value) => normalizeMeetApproverId(String(value)),
+    });
+}
+export function getMeetExecApprovalApprovers(params) {
+    return resolveApprovalApprovers({
+        explicit: params.configOverride?.approvers ??
+            resolveMeetAccount(params).config.execApprovals?.approvers ??
+            resolveMeetOwnerApprovers(params.cfg),
+        normalizeApprover: (value) => normalizeMeetApproverId(String(value)),
+    });
+}
+export function isMeetExecApprovalClientEnabled(params) {
+    const config = params.configOverride ?? resolveMeetAccount(params).config.execApprovals;
+    return isChannelExecApprovalClientEnabledFromConfig({
+        enabled: config?.enabled,
+        approverCount: getMeetExecApprovalApprovers({
+            cfg: params.cfg,
+            accountId: params.accountId,
+            configOverride: params.configOverride,
+        }).length,
+    });
+}
+export function isMeetExecApprovalApprover(params) {
+    const senderId = params.senderId?.trim();
+    if (!senderId) {
+        return false;
+    }
+    return getMeetExecApprovalApprovers({
+        cfg: params.cfg,
+        accountId: params.accountId,
+        configOverride: params.configOverride,
+    }).includes(senderId);
+}
+export function shouldSuppressLocalMeetExecApprovalPrompt(params) {
+    const metadata = getExecApprovalReplyMetadata(params.payload);
+    const config = resolveMeetAccount(params).config.execApprovals;
+    return (params.hint?.kind === "approval-pending" &&
+        params.hint.nativeRouteActive === true &&
+        isMeetExecApprovalClientEnabled(params) &&
+        metadata !== null &&
+        matchesApprovalRequestFilters({
+            request: {
+                agentId: metadata.agentId,
+                sessionKey: metadata.sessionKey,
+            },
+            agentFilter: config?.agentFilter,
+            sessionFilter: config?.sessionFilter,
+        }));
+}

package/dist/src/generated/plugin-build-meta.d.ts

@@ -1,2 +1,2 @@
-export declare const MEET_PLUGIN_VERSION = "3.4.5";
+export declare const MEET_PLUGIN_VERSION = "3.6.0";
 export declare const MEET_OPENCLAW_VERSION = "2026.5.18";

package/dist/src/generated/plugin-build-meta.js

@@ -1,2 +1,2 @@
-export const MEET_PLUGIN_VERSION = "3.4.5";
+export const MEET_PLUGIN_VERSION = "3.6.0";
 export const MEET_OPENCLAW_VERSION = "2026.5.18";

package/dist/src/outbound.js

@@ -1,5 +1,6 @@
 import { getMeetRuntime } from "./runtime.js";
 import { sendMessageMeet, sendMediaMeet } from "./send.js";
+import { shouldSuppressLocalMeetExecApprovalPrompt } from "./exec-approvals.js";
 export const meetOutbound = {
     deliveryMode: "direct",
     chunker: (text, limit) => {
@@ -31,4 +32,12 @@ export const meetOutbound = {
         });
         return { channel: "meet", messageId: result.messageId, chatId: result.chatId };
     },
+    shouldSuppressLocalPayloadPrompt: (params) => {
+        return shouldSuppressLocalMeetExecApprovalPrompt({
+            cfg: params.cfg,
+            accountId: params.accountId,
+            payload: params.payload,
+            hint: params.hint,
+        });
+    },
 };

package/dist/src/reply-dispatcher.d.ts

@@ -15,6 +15,7 @@ export type CreateMeetReplyDispatcherOpts = {
     agentId: string;
     runtime: RuntimeEnv;
     chatId: string;
+    threadId?: string;
     senderId?: string;
     mentionedBot?: boolean;
     replyToMessageId?: string;
@@ -28,11 +29,20 @@ export type CreateMeetReplyDispatcherOpts = {
     typingMode?: "none" | "instant" | "message";
 };
 export declare function createMeetReplyDispatcher(opts: CreateMeetReplyDispatcherOpts): Promise<{
-    dispatcher: import("node_modules/openclaw/dist/plugin-sdk/src/auto-reply/reply/reply-dispatcher.types.js").ReplyDispatcher;
+    dispatcher: import("node_modules/openclaw/dist/plugin-sdk/reply-dispatcher.types-B0sivCQE.js").r;
     replyOptions: {
         sourceReplyDeliveryMode?: import("openclaw/plugin-sdk/channel-reply-pipeline").SourceReplyDeliveryMode | undefined;
         onReplyStart?: (() => Promise<void> | void) | undefined;
-        onTypingController?: ((typing: import("node_modules/openclaw/dist/plugin-sdk/src/auto-reply/reply/typing.js").TypingController) => void) | undefined;
+        onTypingController?: ((typing: {
+            onReplyStart: () => Promise<void>;
+            startTypingLoop: () => Promise<void>;
+            startTypingOnText: (text?: string) => Promise<void>;
+            refreshTypingTtl: () => void;
+            isActive: () => boolean;
+            markRunComplete: () => void;
+            markDispatchIdle: () => void;
+            cleanup: () => void;
+        }) => void) | undefined;
         onTypingCleanup?: (() => void) | undefined;
     };
     markDispatchIdle: () => void;

package/dist/src/reply-dispatcher.js

@@ -83,7 +83,7 @@ export function protectMentionsInChunks(chunks) {
     return result;
 }
 export async function createMeetReplyDispatcher(opts) {
-    const { cfg, agentId, chatId, senderId, mentionedBot, replyToMessageId, accountId, mediaLocalRoots, sessionInfo, apiToken, apiEndpoint, typingMode } = opts;
+    const { cfg, agentId, chatId, threadId, senderId, mentionedBot, replyToMessageId, accountId, mediaLocalRoots, sessionInfo, apiToken, apiEndpoint, typingMode } = opts;
     const core = getMeetRuntime();
     const textChunkLimit = core.channel.text.resolveTextChunkLimit(cfg, "meet", accountId, {
         fallbackLimit: 4000,
@@ -210,6 +210,7 @@ export async function createMeetReplyDispatcher(opts) {
                 await sendMediaMeet({
                     cfg,
                     to: chatId,
+                    threadId,
                     text: text.trim() || undefined,
                     mediaUrl: mediaUrls[0],
                     mediaLocalRoots,
@@ -221,6 +222,7 @@ export async function createMeetReplyDispatcher(opts) {
                     await sendMediaMeet({
                         cfg,
                         to: chatId,
+                        threadId,
                         text: undefined,
                         mediaUrl: mediaUrls[i],
                         mediaLocalRoots,
@@ -242,6 +244,7 @@ export async function createMeetReplyDispatcher(opts) {
                 await sendMessageMeet({
                     cfg,
                     to: chatId,
+                    threadId,
                     text: chunk,
                     accountId,
                     replyToMessageId,
@@ -290,6 +293,7 @@ export async function createMeetReplyDispatcher(opts) {
                 await sendMessageMeet({
                     cfg,
                     to: chatId,
+                    threadId,
                     text: userMessage,
                     accountId,
                     runtime: opts.runtime,

package/dist/src/route-peer.d.ts

@@ -0,0 +1,6 @@
+export declare function buildMeetRoutePeerId(params: {
+    isGroup: boolean;
+    senderId: string;
+    chatId: string;
+    threadId?: string;
+}): string;

package/dist/src/route-peer.js

@@ -0,0 +1,6 @@
+export function buildMeetRoutePeerId(params) {
+    if (params.isGroup) {
+        return params.chatId;
+    }
+    return params.threadId ? `${params.senderId}__topic__${params.threadId}` : params.senderId;
+}

package/dist/src/sdk-bridge.d.ts

@@ -25,3 +25,13 @@ export declare function msgContentToContext(msg: MsgContent, botUserId: string,
 export declare function enrichContextWithUserNames(ctx: MeetMessageContext, bot: MeetBot, accountId?: string): Promise<void>;
 export declare function parseTargetToSessionInfo(target: string, botUserId: number): SessionInfo;
 export declare function buildMeetTarget(sessionInfo: SessionInfo, botUserId: number): string;
+export interface MergedForwardEntry {
+    sender: string;
+    body: string;
+    timestamp?: number;
+    messageId: string;
+}
+/**
+ * 解析合并转发消息的 content，展开为多条可读记录
+ */
+export declare function parseMergedForwardContent(content: string): MergedForwardEntry[];

package/dist/src/sdk-bridge.js

@@ -1,3 +1,4 @@
+import { encodeMeetDmTopicId } from "./dm-topic-codec.js";
 import { rememberMeetUser } from "./directory-cache.js";
 export function mapSessionType(sessionType) {
     return sessionType === 1 ? "direct" : "channel";
@@ -159,6 +160,9 @@ export function msgContentToContext(msg, botUserId, quoteMsgMap = {}) {
     const chatId = chatType === "direct"
         ? `user:${msg.fromUid}`
         : `channel:${msg.sessionInfo.secondID}`;
+    const threadId = chatType === "direct" && typeof msg.dmTopicID === "string" && msg.dmTopicID.trim()
+        ? encodeMeetDmTopicId(msg.dmTopicID)
+        : undefined;
     const mentionedBot = msg.atIds?.includes(Number(botUserId)) ?? false;
     const replyContext = resolveQuoteMessage(msg, quoteMsgMap);
     const media = extractMediaAttachments(msg);
@@ -171,6 +175,7 @@ export function msgContentToContext(msg, botUserId, quoteMsgMap = {}) {
     }
     return {
         chatId,
+        threadId,
         messageId: String(msg.seqId ?? 0),
         senderId: String(msg.fromUid ?? 0),
         senderOpenId: String(msg.fromUid ?? 0),
@@ -302,3 +307,44 @@ export function buildMeetTarget(sessionInfo, botUserId) {
     }
     return `channel:${sessionInfo.secondID}`;
 }
+/**
+ * 解析合并转发消息的 content，展开为多条可读记录
+ */
+export function parseMergedForwardContent(content) {
+    let parsed;
+    try {
+        parsed = JSON.parse(content);
+    }
+    catch {
+        return [];
+    }
+    const msgs = parsed.msgs;
+    if (!Array.isArray(msgs) || msgs.length === 0) {
+        return [];
+    }
+    const profileMap = parsed.userProfileMap ?? {};
+    const buildAttachmentPlaceholder = (sub) => {
+        const attachments = [
+            ...(sub.extraInfo?.attechmentInfo ? [sub.extraInfo.attechmentInfo] : []),
+            ...(Array.isArray(sub.extraInfo?.attechmentInfos) ? sub.extraInfo.attechmentInfos : []),
+        ];
+        if (attachments.length === 0) {
+            return "";
+        }
+        return attachments
+            .map((attachment) => `[attachment:${attachment.fileName || attachment.mimeType || "file"}]`)
+            .join(" ");
+    };
+    return msgs.map((sub, i) => {
+        const senderId = String(sub.fromUid ?? 0);
+        const profile = profileMap[senderId];
+        const sender = profile?.nickName || senderId;
+        const attachmentPlaceholder = buildAttachmentPlaceholder(sub);
+        return {
+            sender,
+            body: [sub.content?.trim() || "", attachmentPlaceholder].filter(Boolean).join(" "),
+            timestamp: sub.timestamp,
+            messageId: String(sub.seqId ?? `merged-${i}`),
+        };
+    });
+}

package/dist/src/send.d.ts

@@ -15,11 +15,17 @@ export declare function extractAtIds(text: string): {
     atIds: number[];
 };
 export declare function mergeAtIds(explicitAtIds?: number[], extractedAtIds?: number[]): number[];
+export declare function resolveMeetThreadTarget<T extends {
+    sessionType: number;
+}>(sessionInfo: T, threadId?: string): T | (T & {
+    threadId?: number;
+});
 export type SendMessageMeetOpts = {
     cfg: ClawdbotConfig;
     to: string;
     text: string;
     accountId?: string;
+    threadId?: string;
     replyToMessageId?: string;
     atIds?: number[];
     /** Optional runtime for consistent logging. If not provided, falls back to console. */
@@ -32,6 +38,7 @@ export declare function sendMessageMeet(opts: SendMessageMeetOpts): Promise<{
 export type SendMediaMeetOpts = {
     cfg: ClawdbotConfig;
     to: string;
+    threadId?: string;
     text?: string;
     mediaUrl: string;
     mediaLocalRoots?: readonly string[];

package/dist/src/send.js

@@ -1,5 +1,6 @@
 import { resolveMeetAccount } from "./accounts.js";
 import { getMeetClient, createMeetClient } from "./client.js";
+import { decodeMeetDmTopicThreadId } from "./dm-topic-codec.js";
 import { parseTargetToSessionInfo } from "./sdk-bridge.js";
 import { getMeetRuntime } from "./runtime.js";
 import { rewriteMeetKnownMentions } from "./mentions.js";
@@ -122,8 +123,27 @@ export function extractAtIds(text) {
 export function mergeAtIds(explicitAtIds, extractedAtIds) {
     return [...new Set([...(explicitAtIds ?? []), ...(extractedAtIds ?? [])])];
 }
+// OpenClaw upper layers use a channel-agnostic `threadId` abstraction.
+// Meet maps that abstraction differently by session type:
+// - channel/group sessions use Meet `threadId`
+// - direct-message sessions use Meet `dmTopicID`
+export function resolveMeetThreadTarget(sessionInfo, threadId) {
+    if (!threadId) {
+        return sessionInfo;
+    }
+    if (sessionInfo.sessionType === 3) {
+        return {
+            ...sessionInfo,
+            threadId: Number(threadId),
+        };
+    }
+    if (sessionInfo.sessionType === 1) {
+        return sessionInfo;
+    }
+    return sessionInfo;
+}
 export async function sendMessageMeet(opts) {
-    const { cfg, to, text, accountId, atIds: explicitAtIds, runtime } = opts;
+    const { cfg, to, text, accountId, threadId, atIds: explicitAtIds, runtime } = opts;
     const log = runtime?.log ?? console.log;
     const logError = runtime?.error ?? console.error;
     const account = resolveMeetAccount({ cfg, accountId });
@@ -170,10 +190,13 @@ export async function sendMessageMeet(opts) {
     const finalAtIds = mergeAtIds(explicitAtIds, extractedAtIds);
     log(`send message to=${to} atIds=${finalAtIds.join(",") || "none"}`);
     const sessionInfo = parseTargetToSessionInfo(to, Number(botUserId));
+    const finalSessionInfo = resolveMeetThreadTarget(sessionInfo, threadId);
+    const dmTopicID = sessionInfo.sessionType === 1 ? decodeMeetDmTopicThreadId(threadId) : undefined;
     try {
-        const result = await bot.sendMessage(sessionInfo, {
+        const result = await bot.sendMessage(finalSessionInfo, {
             content: cleanText,
             atIds: finalAtIds,
+            ...(dmTopicID ? { dmTopicID } : {}),
         });
         return {
             messageId: String(result.msgContent?.seqId ?? 0),
@@ -186,7 +209,7 @@ export async function sendMessageMeet(opts) {
     }
 }
 export async function sendMediaMeet(opts) {
-    const { cfg, to, text, mediaUrl, mediaLocalRoots, accountId, onProgress, runtime: logRuntime } = opts;
+    const { cfg, to, threadId, text, mediaUrl, mediaLocalRoots, accountId, onProgress, runtime: logRuntime } = opts;
     const log = logRuntime?.log ?? console.log;
     const logError = logRuntime?.error ?? console.error;
     const account = resolveMeetAccount({ cfg, accountId });
@@ -236,6 +259,8 @@ export async function sendMediaMeet(opts) {
         throw new Error(`Media file too large: ${media.buffer.length} bytes (max: ${maxBytes})`);
     }
     const sessionInfo = parseTargetToSessionInfo(to, Number(botUserId));
+    const finalSessionInfo = resolveMeetThreadTarget(sessionInfo, threadId);
+    const dmTopicID = sessionInfo.sessionType === 1 ? decodeMeetDmTopicThreadId(threadId) : undefined;
     const rawFileName = media.fileName || "file";
     const contentType = resolveContentType(rawFileName, media.contentType);
     // 确保文件名有正确的扩展名
@@ -253,11 +278,12 @@ export async function sendMediaMeet(opts) {
         }
         : undefined;
     try {
-        const result = await bot.sendMedia(sessionInfo, {
+        const result = await bot.sendMedia(finalSessionInfo, {
             buffer: media.buffer,
             fileName,
             contentType,
             content: text || "",
+            ...(dmTopicID ? { dmTopicID } : {}),
             onProgress: progressCallback,
         });
         return {

package/dist/src/types.d.ts

@@ -1,10 +1,11 @@
 import type { SessionInfo, AttachmentInfo, UploadProgress } from "@meet-im/meet-bot-jssdk";
 import type { z } from "zod";
-import { MeetConfigSchema, MeetAccountConfigSchema, MeetChannelConfigSchema, MeetGroupConfigSchema } from "./config-schema.js";
+import { MeetConfigSchema, MeetAccountConfigSchema, MeetChannelConfigSchema, MeetGroupConfigSchema, MeetExecApprovalConfigSchema } from "./config-schema.js";
 export type MeetConfig = z.infer<typeof MeetConfigSchema>;
 export type MeetAccountConfig = z.infer<typeof MeetAccountConfigSchema>;
 export type MeetChannelConfig = z.infer<typeof MeetChannelConfigSchema>;
 export type MeetGroupConfig = z.infer<typeof MeetGroupConfigSchema>;
+export type MeetExecApprovalConfig = z.infer<typeof MeetExecApprovalConfigSchema>;
 export type { AttachmentInfo, UploadProgress };
 export type ResolvedMeetAccount = {
     accountId: string;
@@ -29,6 +30,7 @@ export type MeetMention = {
 };
 export type MeetMessageContext = {
     chatId: string;
+    threadId?: string;
     messageId: string;
     senderId: string;
     senderOpenId: string;

package/openclaw.plugin.json

@@ -28,6 +28,22 @@
             "type": "array",
             "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
           },
+          "execApprovals": {
+            "type": "object",
+            "additionalProperties": false,
+            "properties": {
+              "enabled": {
+                "anyOf": [{ "type": "boolean" }, { "type": "string", "const": "auto" }]
+              },
+              "approvers": {
+                "type": "array",
+                "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
+              },
+              "target": { "type": "string", "enum": ["dm", "channel", "both"] },
+              "agentFilter": { "type": "array", "items": { "type": "string" } },
+              "sessionFilter": { "type": "array", "items": { "type": "string" } }
+            }
+          },
           "requireMention": { "type": "boolean" },
           "systemPrompt": { "type": "string" },
           "channels": {
@@ -88,6 +104,22 @@
                   "type": "array",
                   "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
                 },
+                "execApprovals": {
+                  "type": "object",
+                  "additionalProperties": false,
+                  "properties": {
+                    "enabled": {
+                      "anyOf": [{ "type": "boolean" }, { "type": "string", "const": "auto" }]
+                    },
+                    "approvers": {
+                      "type": "array",
+                      "items": { "anyOf": [{ "type": "string" }, { "type": "number" }] }
+                    },
+                    "target": { "type": "string", "enum": ["dm", "channel", "both"] },
+                    "agentFilter": { "type": "array", "items": { "type": "string" } },
+                    "sessionFilter": { "type": "array", "items": { "type": "string" } }
+                  }
+                },
                 "requireMention": { "type": "boolean" },
                 "systemPrompt": { "type": "string" },
                 "historyLimit": { "type": "number", "minimum": 0 },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meet-im/meet",
-  "version": "3.4.5",
+  "version": "3.6.0",
   "type": "module",
   "description": "OpenClaw Meet channel plugin",
   "scripts": {

package/skills/meet-lxcli-guide/SKILL.md

@@ -285,5 +285,5 @@ lxcli kb --help
 lxcli kb getTask --task_id 123
 lxcli kb createTask --help
 lxcli kb createComment --help
-npx skills add https://github.com/LynkTechnology/lxcli -y
+npx skills add https://github.com/LynkTechnology/lxcli -g
 ```