@meet-im/meet 3.0.1 → 3.2.1

package/dist/runtime-setter-api.js

@@ -1,2 +1,8 @@
+import { initMeetUserAgent } from "./src/client.js";
+import { resolveMeetOpenClawVersion, resolveMeetPluginVersion } from "./src/plugin-version.js";
 // Keep bundled registration fast: runtime wiring only needs the store setter.
+initMeetUserAgent({
+    pluginVersion: resolveMeetPluginVersion(),
+    openclawVersion: resolveMeetOpenClawVersion(),
+});
 export { setMeetRuntime } from "./src/runtime.js";

package/dist/src/bot.d.ts

@@ -1,7 +1,7 @@
 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";
+import type { ResolvedMeetAccount, MeetMessageContext } from "./types.js";
 export declare function handleMeetMessage(params: {
     cfg: ClawdbotConfig;
     msg: MsgContent;
@@ -12,4 +12,5 @@ export declare function handleMeetMessage(params: {
     bot: MeetBot;
     groupHistories: Map<string, HistoryEntry[]>;
     quoteMsgMap?: Record<string, MsgContent>;
+    ctx?: MeetMessageContext;
 }): Promise<void>;

package/dist/src/bot.js

@@ -12,12 +12,12 @@ 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 { cfg, msg, botUserId, runtime, accountId, account, bot, groupHistories, quoteMsgMap, ctx: providedCtx } = params;
     const log = runtime?.log ?? console.log;
     const error = runtime?.error ?? console.error;
     let ctx;
     try {
-        ctx = msgContentToContext(msg, botUserId, quoteMsgMap);
+        ctx = providedCtx ?? msgContentToContext(msg, botUserId, quoteMsgMap);
     }
     catch (err) {
         error(`[${accountId}]: failed to parse message: ${String(err)}`);
@@ -235,9 +235,12 @@ export async function handleMeetMessage(params) {
         // 构建最终的消息内容
         // Discord 做法：文字优先，无文字时用媒体占位符
         // 媒体路径通过 MediaPaths 传递，mediaContext 仅作为 BodyForAgent 的补充描述
+        const mentionsContext = ctx.mentions && ctx.mentions.length > 0
+            ? `\n\nMentioned users: ${ctx.mentions.map((m) => `${m.name} (${m.userId})`).join(", ")}`
+            : "";
         const finalContent = ctx.content.trim()
-            ? `${ctx.content.trim()}${mediaContext}`
-            : (ctx.placeholder || "") + mediaContext;
+            ? `${ctx.content.trim()}${mentionsContext}${mediaContext}`
+            : (ctx.placeholder || "") + mentionsContext + mediaContext;
         // Discord 做法：跳过空内容消息
         if (!finalContent.trim() && mediaPaths.length === 0) {
             log(`[${accountId}]: skip message ${ctx.messageId} (empty content)`);
@@ -301,7 +304,7 @@ export async function handleMeetMessage(params) {
             SessionKey: route.sessionKey,
             AccountId: route.accountId,
             ChatType: isGroup ? "group" : "direct",
-            GroupSubject: isGroup ? ctx.chatId : undefined,
+            GroupSubject: isGroup ? (groupConfig?.groupConfig?.name ?? ctx.chatId) : undefined,
             GroupSystemPrompt: systemPrompt,
             SenderName: ctx.senderName,
             SenderId: ctx.senderId,
@@ -313,6 +316,7 @@ export async function handleMeetMessage(params) {
             ReplyToId: ctx.replyContext?.messageId,
             ReplyToBody: ctx.replyContext?.content,
             ReplyToSender: ctx.replyContext?.senderId,
+            MentionedUsers: ctx.mentions,
             InboundHistory: inboundHistory,
             CommandAuthorized: true,
             OriginatingChannel: "meet",

package/dist/src/channel.js

@@ -4,6 +4,8 @@ import { resolveMeetAccount, listMeetAccountIds, resolveDefaultMeetAccountId, is
 import { meetOutbound } from "./outbound.js";
 import { parseMeetTarget, looksLikeMeetId, formatMeetTarget, } from "./targets.js";
 import { sendMessageMeet } from "./send.js";
+import { getMeetClient } from "./client.js";
+import { getAllCachedUsers, rememberMeetUser } from "./directory-cache.js";
 const meta = {
     id: "meet",
     label: "Meet",
@@ -339,9 +341,56 @@ export const meetPlugin = {
     },
     directory: {
         self: async () => null,
-        listPeers: async () => [],
+        listPeers: async (params) => {
+            const { accountId, query, limit } = params;
+            if (!accountId)
+                return [];
+            const normalizedAccountId = normalizeAccountId(accountId);
+            const users = getAllCachedUsers({ accountId: normalizedAccountId, query, limit });
+            return users.map((u) => ({
+                kind: "user",
+                id: u.userId,
+                name: u.name,
+                handle: u.handles[0] ?? u.name,
+            }));
+        },
         listGroups: async () => [],
-        listPeersLive: async () => [],
+        listPeersLive: async (params) => {
+            const { accountId, query, limit, runtime } = params;
+            const log = runtime?.log ?? console.log;
+            if (!query || !accountId) {
+                log(`[meet] listPeersLive: missing query or accountId`);
+                return [];
+            }
+            const normalizedAccountId = normalizeAccountId(accountId);
+            const bot = getMeetClient(normalizedAccountId);
+            if (!bot) {
+                log(`[meet] listPeersLive: no bot client for account ${normalizedAccountId}`);
+                return [];
+            }
+            try {
+                const users = await bot.searchUserByName(query);
+                log(`[meet] listPeersLive: searchUserByName("${query}") => ${users.length} users`);
+                const sliced = limit ? users.slice(0, limit) : users;
+                for (const user of sliced) {
+                    rememberMeetUser({
+                        accountId: normalizedAccountId,
+                        userId: user.userID,
+                        handles: [user.nickName, user.aliasName],
+                    });
+                }
+                return sliced.map((u) => ({
+                    kind: "user",
+                    id: String(u.userID),
+                    name: u.aliasName || u.nickName,
+                    handle: u.aliasName || u.nickName,
+                }));
+            }
+            catch (err) {
+                log(`[meet] listPeersLive: searchUserByName error: ${String(err)}`);
+                return [];
+            }
+        },
         listGroupsLive: async () => [],
     },
     outbound: meetOutbound,

package/dist/src/client.d.ts

@@ -1,6 +1,12 @@
 import { MeetBot } from "@meet-im/meet-bot-jssdk";
 import type { PollingOptions } from "@meet-im/meet-bot-jssdk";
 import type { ResolvedMeetAccount } from "./types.js";
+export declare function getPluginUserAgent(): string;
+export declare function initMeetUserAgent(options: {
+    pluginVersion?: string;
+    openclawVersion?: string;
+}): void;
+export declare function setOpenClawVersion(version: string): void;
 export declare function createMeetClient(account: ResolvedMeetAccount): MeetBot;
 export declare function getPollingOptions(account: ResolvedMeetAccount): PollingOptions;
 export declare function getMeetClient(accountId: string): MeetBot | undefined;

package/dist/src/client.js

@@ -1,4 +1,26 @@
+import os from "node:os";
 import { MeetBot, POLLING } from "@meet-im/meet-bot-jssdk";
+let _pluginVersion = "unknown";
+let _openclawVersion = "unknown";
+function buildUserAgent() {
+    return `MeetPlugin/${_pluginVersion} (Node/${process.versions.node}; ${os.platform()}; OpenClaw/${_openclawVersion})`;
+}
+export function getPluginUserAgent() {
+    return buildUserAgent();
+}
+export function initMeetUserAgent(options) {
+    if (options.pluginVersion) {
+        _pluginVersion = options.pluginVersion;
+    }
+    if (options.openclawVersion) {
+        _openclawVersion = options.openclawVersion;
+    }
+}
+export function setOpenClawVersion(version) {
+    if (version) {
+        _openclawVersion = version;
+    }
+}
 const botInstances = new Map();
 export function createMeetClient(account) {
     const existing = botInstances.get(account.accountId);
@@ -18,6 +40,7 @@ export function createMeetClient(account) {
         longPollingTimeout: pollTimeoutSec,
         logLevel,
         useV2: true,
+        userAgent: buildUserAgent(),
     });
     botInstances.set(account.accountId, bot);
     return bot;

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

@@ -23,6 +23,31 @@ export declare const MeetAccountConfigSchema: z.ZodObject<{
         silent: "silent";
         info: "info";
     }>>;
+    dmPolicy: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        pairing: "pairing";
+        allowlist: "allowlist";
+    }>>;
+    allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    groupPolicy: z.ZodOptional<z.ZodEnum<{
+        open: "open";
+        allowlist: "allowlist";
+        disabled: "disabled";
+    }>>;
+    groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    requireMention: z.ZodOptional<z.ZodBoolean>;
+    systemPrompt: z.ZodOptional<z.ZodString>;
+    historyLimit: z.ZodOptional<z.ZodNumber>;
+    dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
+    textChunkLimit: z.ZodOptional<z.ZodNumber>;
+    mediaMaxMb: z.ZodOptional<z.ZodNumber>;
+    groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+        enabled: z.ZodOptional<z.ZodBoolean>;
+        name: z.ZodOptional<z.ZodString>;
+        requireMention: z.ZodOptional<z.ZodBoolean>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        users: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+    }, z.core.$strip>>>;
 }, z.core.$strip>;
 export declare const MeetConfigSchema: z.ZodObject<{
     enabled: z.ZodOptional<z.ZodBoolean>;
@@ -78,5 +103,30 @@ export declare const MeetConfigSchema: z.ZodObject<{
             silent: "silent";
             info: "info";
         }>>;
+        dmPolicy: z.ZodOptional<z.ZodEnum<{
+            open: "open";
+            pairing: "pairing";
+            allowlist: "allowlist";
+        }>>;
+        allowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        groupPolicy: z.ZodOptional<z.ZodEnum<{
+            open: "open";
+            allowlist: "allowlist";
+            disabled: "disabled";
+        }>>;
+        groupAllowFrom: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        requireMention: z.ZodOptional<z.ZodBoolean>;
+        systemPrompt: z.ZodOptional<z.ZodString>;
+        historyLimit: z.ZodOptional<z.ZodNumber>;
+        dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
+        textChunkLimit: z.ZodOptional<z.ZodNumber>;
+        mediaMaxMb: z.ZodOptional<z.ZodNumber>;
+        groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
+            enabled: z.ZodOptional<z.ZodBoolean>;
+            name: z.ZodOptional<z.ZodString>;
+            requireMention: z.ZodOptional<z.ZodBoolean>;
+            systemPrompt: z.ZodOptional<z.ZodString>;
+            users: z.ZodOptional<z.ZodArray<z.ZodUnion<readonly [z.ZodString, z.ZodNumber]>>>;
+        }, z.core.$strip>>>;
     }, z.core.$strip>>>;
 }, z.core.$strip>;

package/dist/src/config-schema.js

@@ -20,6 +20,17 @@ export const MeetAccountConfigSchema = z.object({
     pollTimeout: z.number().min(1000).max(300000).optional(),
     pollLimit: z.number().min(1).max(1000).optional(),
     logLevel: z.enum(["silent", "info"]).optional(),
+    dmPolicy: z.enum(["open", "pairing", "allowlist"]).optional(),
+    allowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    groupPolicy: z.enum(["open", "allowlist", "disabled"]).optional(),
+    groupAllowFrom: z.array(z.union([z.string(), z.number()])).optional(),
+    requireMention: z.boolean().optional(),
+    systemPrompt: z.string().optional(),
+    historyLimit: z.number().min(0).optional(),
+    dmHistoryLimit: z.number().min(0).optional(),
+    textChunkLimit: z.number().min(1).optional(),
+    mediaMaxMb: z.number().min(0).optional(),
+    groups: z.record(z.string(), MeetGroupConfigSchema).optional(),
 });
 export const MeetConfigSchema = z.object({
     enabled: z.boolean().optional(),

package/dist/src/directory-cache.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Meet 用户目录缓存
+ * 用于出站消息中 @handle → <@userId> 转换
+ */
+/**
+ * 注册用户到目录缓存
+ */
+export declare function rememberMeetUser(params: {
+    accountId: string;
+    userId: number;
+    handles: (string | null | undefined)[];
+}): void;
+/**
+ * 从目录缓存查找 userId
+ */
+export declare function resolveMeetUserId(params: {
+    accountId?: string | null;
+    handle: string;
+}): string | null;
+/**
+ * 清除指定账户的缓存
+ */
+export declare function clearMeetDirectoryCache(accountId: string): void;
+/**
+ * 清除所有缓存
+ */
+export declare function clearAllMeetDirectoryCache(): void;
+/**
+ * 获取缓存大小（用于测试）
+ */
+export declare function getMeetDirectoryCacheSize(accountId: string): number;
+/**
+ * 获取指定账户的所有缓存用户（用于 listPeers）
+ */
+export declare function getAllCachedUsers(params: {
+    accountId?: string | null;
+    query?: string | null;
+    limit?: number | null;
+}): {
+    userId: string;
+    name: string;
+    handles: string[];
+}[];

package/dist/src/directory-cache.js

@@ -0,0 +1,125 @@
+/**
+ * Meet 用户目录缓存
+ * 用于出站消息中 @handle → <@userId> 转换
+ */
+const DIRECTORY_CACHE_MAX_ENTRIES = 4000;
+const DIRECTORY_HANDLE_CACHE = new Map();
+const DIRECTORY_USER_CACHE = new Map();
+function getAccountCache(accountId) {
+    let cache = DIRECTORY_HANDLE_CACHE.get(accountId);
+    if (!cache) {
+        cache = new Map();
+        DIRECTORY_HANDLE_CACHE.set(accountId, cache);
+    }
+    return cache;
+}
+function getUserCache(accountId) {
+    let cache = DIRECTORY_USER_CACHE.get(accountId);
+    if (!cache) {
+        cache = new Map();
+        DIRECTORY_USER_CACHE.set(accountId, cache);
+    }
+    return cache;
+}
+function normalizeHandle(raw) {
+    const handle = raw?.trim().toLowerCase();
+    if (!handle)
+        return null;
+    return handle;
+}
+/**
+ * 注册用户到目录缓存
+ */
+export function rememberMeetUser(params) {
+    const { accountId, userId, handles } = params;
+    const cache = getAccountCache(accountId);
+    const userCache = getUserCache(accountId);
+    const userIdStr = String(userId);
+    const validHandles = [];
+    for (const rawHandle of handles) {
+        const handle = normalizeHandle(rawHandle ?? "");
+        if (!handle)
+            continue;
+        validHandles.push(rawHandle ?? handle);
+        if (cache.size >= DIRECTORY_CACHE_MAX_ENTRIES && !cache.has(handle)) {
+            const firstKey = cache.keys().next().value;
+            if (firstKey)
+                cache.delete(firstKey);
+        }
+        cache.set(handle, userIdStr);
+    }
+    // 存储用户信息（用第一个非空 handle 作为 name）
+    if (validHandles.length > 0) {
+        const existing = userCache.get(userIdStr);
+        const name = validHandles[0];
+        if (existing) {
+            // 合并 handles
+            const mergedHandles = [...new Set([...existing.handles, ...validHandles])];
+            userCache.set(userIdStr, { name: existing.name || name, handles: mergedHandles });
+        }
+        else {
+            userCache.set(userIdStr, { name, handles: validHandles });
+        }
+    }
+}
+/**
+ * 从目录缓存查找 userId
+ */
+export function resolveMeetUserId(params) {
+    const { accountId, handle } = params;
+    if (!accountId)
+        return null;
+    const normalized = normalizeHandle(handle);
+    if (!normalized)
+        return null;
+    const cache = DIRECTORY_HANDLE_CACHE.get(accountId);
+    if (!cache)
+        return null;
+    return cache.get(normalized) ?? null;
+}
+/**
+ * 清除指定账户的缓存
+ */
+export function clearMeetDirectoryCache(accountId) {
+    DIRECTORY_HANDLE_CACHE.delete(accountId);
+    DIRECTORY_USER_CACHE.delete(accountId);
+}
+/**
+ * 清除所有缓存
+ */
+export function clearAllMeetDirectoryCache() {
+    DIRECTORY_HANDLE_CACHE.clear();
+    DIRECTORY_USER_CACHE.clear();
+}
+/**
+ * 获取缓存大小（用于测试）
+ */
+export function getMeetDirectoryCacheSize(accountId) {
+    return DIRECTORY_HANDLE_CACHE.get(accountId)?.size ?? 0;
+}
+/**
+ * 获取指定账户的所有缓存用户（用于 listPeers）
+ */
+export function getAllCachedUsers(params) {
+    const { accountId, query, limit } = params;
+    if (!accountId)
+        return [];
+    const userCache = DIRECTORY_USER_CACHE.get(accountId);
+    if (!userCache)
+        return [];
+    const normalizedQuery = query?.trim().toLowerCase() ?? "";
+    const results = [];
+    for (const [userId, info] of userCache) {
+        if (normalizedQuery) {
+            const matchesQuery = info.name.toLowerCase().includes(normalizedQuery) ||
+                info.handles.some((h) => h.toLowerCase().includes(normalizedQuery)) ||
+                userId === normalizedQuery;
+            if (!matchesQuery)
+                continue;
+        }
+        results.push({ userId, ...info });
+        if (limit && results.length >= limit)
+            break;
+    }
+    return results;
+}

package/dist/src/mentions.d.ts

@@ -0,0 +1,9 @@
+/**
+ * Meet @提及 重写
+ * 将 @handle 转换为 <@userId> 格式
+ */
+/**
+ * 重写消息中的 @handle 为 <@userId> 格式
+ * 排除代码块中的内容
+ */
+export declare function rewriteMeetKnownMentions(text: string, accountId?: string | null): string;

package/dist/src/mentions.js

@@ -0,0 +1,44 @@
+/**
+ * Meet @提及 重写
+ * 将 @handle 转换为 <@userId> 格式
+ */
+import { resolveMeetUserId } from "./directory-cache.js";
+const MARKDOWN_CODE_PATTERN = /```[\s\S]*?```|`[^`\n]*`/g;
+const MENTION_CANDIDATE_PATTERN = /(^|[\s([{"'.,;:!?])@([^\s`@<>{}\[\],;:!?]+(?:（[^）\s`@<>{}\[\],;:!?]+）)?)/gu;
+const EXPLICIT_MENTION_WITH_ID_PATTERN = /@([^\s`@<>{}\[\],;:!?]+(?:（[^）\s`@<>{}\[\],;:!?]+）)?)\s*[(（](\d+)[)）]/gu;
+function rewriteMentionsInSegment(text, accountId) {
+    if (!text.includes("@")) {
+        return text;
+    }
+    return text.replace(MENTION_CANDIDATE_PATTERN, (match, prefix, handle) => {
+        if (!handle)
+            return match;
+        const userId = resolveMeetUserId({ accountId, handle });
+        if (!userId)
+            return match;
+        return `${prefix ?? ""}<@${userId}>`;
+    });
+}
+/**
+ * 重写消息中的 @handle 为 <@userId> 格式
+ * 排除代码块中的内容
+ */
+export function rewriteMeetKnownMentions(text, accountId) {
+    if (!text.includes("@")) {
+        return text;
+    }
+    const withExplicitIds = text.replace(EXPLICIT_MENTION_WITH_ID_PATTERN, (_, _name, id) => {
+        return `<@${id}>`;
+    });
+    let rewritten = "";
+    let offset = 0;
+    MARKDOWN_CODE_PATTERN.lastIndex = 0;
+    for (const match of withExplicitIds.matchAll(MARKDOWN_CODE_PATTERN)) {
+        const matchIndex = match.index ?? 0;
+        rewritten += rewriteMentionsInSegment(withExplicitIds.slice(offset, matchIndex), accountId);
+        rewritten += match[0];
+        offset = matchIndex + match[0].length;
+    }
+    rewritten += rewriteMentionsInSegment(withExplicitIds.slice(offset), accountId);
+    return rewritten;
+}

package/dist/src/monitor.js

@@ -2,7 +2,7 @@ import { KeyedAsyncQueue } from "openclaw/plugin-sdk/keyed-async-queue";
 import { resolveMeetAccount, listEnabledMeetAccounts } from "./accounts.js";
 import { createMeetClient, closeMeetClient, closeAllMeetClients, getPollingOptions } from "./client.js";
 import { handleMeetMessage } from "./bot.js";
-import { msgContentToContext } from "./sdk-bridge.js";
+import { msgContentToContext, enrichContextWithUserNames } from "./sdk-bridge.js";
 export async function monitorMeetProvider(opts = {}) {
     const cfg = opts.config;
     if (!cfg) {
@@ -66,8 +66,9 @@ async function monitorSingleAccount(params) {
         abortSignal?.addEventListener("abort", handleAbort, { once: true });
         bot.on("message", ({ message, quoteMsgMap }) => {
             let queueKey;
+            let ctx;
             try {
-                const ctx = msgContentToContext(message, botUserId, quoteMsgMap);
+                ctx = msgContentToContext(message, botUserId, quoteMsgMap);
                 queueKey = ctx.chatId;
             }
             catch (err) {
@@ -80,6 +81,7 @@ async function monitorSingleAccount(params) {
             log(`[${accountId}]: enqueue message to queue=${queueKey}, queues=${queueSize}, pending=${pendingInQueue}`);
             messageQueue.enqueue(queueKey, async () => {
                 try {
+                    await enrichContextWithUserNames(ctx, bot, accountId);
                     await handleMeetMessage({
                         cfg,
                         msg: message,
@@ -90,6 +92,7 @@ async function monitorSingleAccount(params) {
                         bot,
                         groupHistories,
                         quoteMsgMap,
+                        ctx,
                     });
                 }
                 catch (err) {

package/dist/src/plugin-version.d.ts

@@ -0,0 +1,2 @@
+export declare function resolveMeetPluginVersion(): string;
+export declare function resolveMeetOpenClawVersion(): string;

package/dist/src/plugin-version.js

@@ -0,0 +1,7 @@
+import packageJson from "../package.json" with { type: "json" };
+export function resolveMeetPluginVersion() {
+    return packageJson.version;
+}
+export function resolveMeetOpenClawVersion() {
+    return packageJson.peerDependencies?.openclaw ?? packageJson.devDependencies?.openclaw ?? "unknown";
+}

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

@@ -23,7 +23,12 @@ export type CreateMeetReplyDispatcherOpts = {
 };
 export declare function createMeetReplyDispatcher(opts: CreateMeetReplyDispatcherOpts): Promise<{
     dispatcher: import("node_modules/openclaw/dist/plugin-sdk/src/auto-reply/reply/reply-dispatcher.types.js").ReplyDispatcher;
-    replyOptions: Pick<import("node_modules/openclaw/dist/plugin-sdk/src/auto-reply/get-reply-options.types.js").GetReplyOptions, "onReplyStart" | "onTypingController" | "onTypingCleanup">;
+    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;
+        onTypingCleanup?: (() => void) | undefined;
+    };
     markDispatchIdle: () => void;
     markRunComplete: () => void;
 }>;

package/dist/src/reply-dispatcher.js

@@ -1,6 +1,25 @@
+import { resolveChannelSourceReplyDeliveryMode } from "openclaw/plugin-sdk/channel-reply-pipeline";
 import { createReplyPrefixContext } from "openclaw/plugin-sdk/channel-runtime";
 import { getMeetRuntime } from "./runtime.js";
 import { sendMessageMeet, sendMediaMeet } from "./send.js";
+function resolveMeetConversationType(chatId) {
+    if (chatId.startsWith("channel:")) {
+        return "group";
+    }
+    if (chatId.startsWith("user:")) {
+        return "direct";
+    }
+    return undefined;
+}
+function resolveMeetChatType(chatId) {
+    if (chatId.startsWith("channel:")) {
+        return "channel";
+    }
+    if (chatId.startsWith("user:")) {
+        return "direct";
+    }
+    return undefined;
+}
 /**
  * 匹配末尾不完整的 mention 开始: <@ 或 <@xxx (没有闭合的 >)
  */
@@ -61,9 +80,21 @@ export async function createMeetReplyDispatcher(opts) {
     });
     const chunkMode = core.channel.text.resolveChunkMode(cfg, "meet", accountId);
     const prefixContext = createReplyPrefixContext({ cfg, agentId });
+    const chatType = resolveMeetChatType(chatId);
+    const sourceReplyDeliveryMode = chatType
+        ? resolveChannelSourceReplyDeliveryMode({
+            cfg,
+            ctx: { ChatType: chatType },
+        })
+        : undefined;
     const { dispatcher, replyOptions, markDispatchIdle, markRunComplete } = core.channel.reply.createReplyDispatcherWithTyping({
         responsePrefix: prefixContext.responsePrefix,
         responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+        silentReplyContext: {
+            cfg,
+            surface: "meet",
+            conversationType: resolveMeetConversationType(chatId),
+        },
         humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
         onReplyStart: async () => {
         },
@@ -166,7 +197,10 @@ export async function createMeetReplyDispatcher(opts) {
     });
     return {
         dispatcher,
-        replyOptions,
+        replyOptions: {
+            ...replyOptions,
+            ...(sourceReplyDeliveryMode ? { sourceReplyDeliveryMode } : {}),
+        },
         markDispatchIdle,
         markRunComplete,
     };

package/dist/src/runtime.d.ts

@@ -7,5 +7,6 @@ export type MeetRuntime = PluginRuntime & {
         meet?: MeetChannelRuntime;
     };
 };
-declare const setMeetRuntime: (next: MeetRuntime) => void, getOptionalMeetRuntime: () => MeetRuntime | null, getMeetRuntime: () => MeetRuntime;
-export { getMeetRuntime, getOptionalMeetRuntime, setMeetRuntime };
+declare const getOptionalMeetRuntime: () => MeetRuntime | null, getMeetRuntime: () => MeetRuntime;
+export declare function setMeetRuntime(runtime: MeetRuntime): void;
+export { getMeetRuntime, getOptionalMeetRuntime };

package/dist/src/runtime.js

@@ -1,6 +1,13 @@
 import { createPluginRuntimeStore } from "openclaw/plugin-sdk/runtime-store";
-const { setRuntime: setMeetRuntime, tryGetRuntime: getOptionalMeetRuntime, getRuntime: getMeetRuntime, } = createPluginRuntimeStore({
+import { setOpenClawVersion } from "./client.js";
+const { setRuntime: setMeetRuntimeStore, tryGetRuntime: getOptionalMeetRuntime, getRuntime: getMeetRuntime, } = createPluginRuntimeStore({
     pluginId: "meet",
     errorMessage: "Meet runtime not initialized",
 });
-export { getMeetRuntime, getOptionalMeetRuntime, setMeetRuntime };
+export function setMeetRuntime(runtime) {
+    if (runtime.version) {
+        setOpenClawVersion(runtime.version);
+    }
+    setMeetRuntimeStore(runtime);
+}
+export { getMeetRuntime, getOptionalMeetRuntime };

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

@@ -1,4 +1,4 @@
-import type { MsgContent, SessionInfo, SessionType } from "@meet-im/meet-bot-jssdk";
+import type { MsgContent, SessionInfo, SessionType, MeetBot } from "@meet-im/meet-bot-jssdk";
 import type { MeetMessageContext, MeetReplyContext, MeetMediaAttachment } from "./types.js";
 export type QuoteMsgMap = Record<string, MsgContent>;
 export declare function mapSessionType(sessionType: SessionType): "direct" | "channel";
@@ -17,5 +17,10 @@ export declare function resolveQuoteMessage(msg: MsgContent, quoteMsgMap: QuoteM
  */
 export declare function extractQuoteMessageMedia(msg: MsgContent, quoteMsgMap: QuoteMsgMap): MeetMediaAttachment[] | undefined;
 export declare function msgContentToContext(msg: MsgContent, botUserId: string, quoteMsgMap?: QuoteMsgMap): MeetMessageContext;
+/**
+ * 从缓存中填充 senderName 和 atIds 对应的用户名
+ * 同时将用户名注册到目录缓存，用于出站 @提及 转换
+ */
+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;

package/dist/src/sdk-bridge.js

@@ -1,3 +1,4 @@
+import { rememberMeetUser } from "./directory-cache.js";
 export function mapSessionType(sessionType) {
     return sessionType === 1 ? "direct" : "channel";
 }
@@ -177,6 +178,86 @@ export function msgContentToContext(msg, botUserId, quoteMsgMap = {}) {
         media,
     };
 }
+/**
+ * 从缓存中填充 senderName 和 atIds 对应的用户名
+ * 同时将用户名注册到目录缓存，用于出站 @提及 转换
+ */
+export async function enrichContextWithUserNames(ctx, bot, accountId) {
+    const userIds = new Set();
+    const senderId = Number(ctx.senderId);
+    if (senderId > 0)
+        userIds.add(senderId);
+    if (ctx.atIds) {
+        for (const id of ctx.atIds)
+            userIds.add(id);
+    }
+    if (ctx.replyContext?.senderId) {
+        const replySenderId = Number(ctx.replyContext.senderId);
+        if (replySenderId > 0)
+            userIds.add(replySenderId);
+    }
+    if (userIds.size === 0)
+        return;
+    const users = await bot.getUserByIds([...userIds]);
+    const sender = users.get(senderId);
+    if (sender) {
+        ctx.senderName = sender.aliasName || sender.nickName;
+        if (accountId) {
+            rememberMeetUser({
+                accountId,
+                userId: senderId,
+                handles: [sender.nickName, sender.aliasName],
+            });
+        }
+    }
+    if (ctx.replyContext?.senderId) {
+        const replySender = users.get(Number(ctx.replyContext.senderId));
+        if (replySender) {
+            ctx.replyContext.senderName = replySender.aliasName || replySender.nickName;
+            if (accountId) {
+                rememberMeetUser({
+                    accountId,
+                    userId: replySender.userID,
+                    handles: [replySender.nickName, replySender.aliasName],
+                });
+            }
+        }
+    }
+    if (ctx.atIds && ctx.atIds.length > 0) {
+        const mentionedNames = [];
+        const mentions = new Map();
+        for (const atId of ctx.atIds) {
+            const user = users.get(atId);
+            if (user) {
+                const displayName = user.aliasName || user.nickName;
+                mentions.set(String(atId), displayName);
+                if (accountId) {
+                    rememberMeetUser({
+                        accountId,
+                        userId: atId,
+                        handles: [user.nickName, user.aliasName],
+                    });
+                }
+                // 替换文本中已有的 <@id> 格式
+                const nextContent = ctx.content.replace(new RegExp(`<@${atId}>`, "g"), `@${displayName}`);
+                const replaced = nextContent !== ctx.content;
+                ctx.content = nextContent;
+                // 如果文本中没有对应的 <@id> 被替换，则追加到列表
+                if (!replaced) {
+                    mentionedNames.push(displayName);
+                }
+            }
+        }
+        ctx.mentions = [...mentions.entries()].map(([userId, name]) => ({ userId, name }));
+        // 如果有未被文本包含的 @提及，追加到内容末尾
+        if (mentionedNames.length > 0) {
+            const mentionText = mentionedNames.map((n) => `@${n}`).join(" ");
+            ctx.content = ctx.content.trim()
+                ? `${ctx.content} ${mentionText}`
+                : mentionText;
+        }
+    }
+}
 export function parseTargetToSessionInfo(target, botUserId) {
     const userMatch = target.match(/^user:(\d+)$/);
     if (userMatch) {

package/dist/src/send.js

@@ -2,6 +2,7 @@ import { resolveMeetAccount } from "./accounts.js";
 import { getMeetClient, createMeetClient } from "./client.js";
 import { parseTargetToSessionInfo } from "./sdk-bridge.js";
 import { getMeetRuntime } from "./runtime.js";
+import { rewriteMeetKnownMentions } from "./mentions.js";
 const MENTION_PATTERN = /<@(-?\d+)>|@(-?\d+)(?![\d])/g;
 /**
  * 根据文件扩展名推断 MIME 类型
@@ -177,7 +178,9 @@ export async function sendMessageMeet(opts) {
     if (!bot) {
         bot = createMeetClient(account);
     }
-    const { text: cleanText, atIds: extractedAtIds } = extractAtIds(text);
+    // 先重写 @handle 为 <@userId>，再提取 atIds
+    const textWithMentions = rewriteMeetKnownMentions(text, account.accountId);
+    const { text: cleanText, atIds: extractedAtIds } = extractAtIds(textWithMentions);
     const finalAtIds = explicitAtIds
         ? [...explicitAtIds, ...extractedAtIds]
         : extractedAtIds;

package/dist/src/types.d.ts

@@ -23,6 +23,10 @@ export type MeetReplyContext = {
     timestamp?: number;
     mediaPaths?: string[];
 };
+export type MeetMention = {
+    userId: string;
+    name: string;
+};
 export type MeetMessageContext = {
     chatId: string;
     messageId: string;
@@ -39,6 +43,7 @@ export type MeetMessageContext = {
     sessionInfo: SessionInfo;
     timestamp?: number;
     atIds?: number[];
+    mentions?: MeetMention[];
     replyContext?: MeetReplyContext;
     media?: MeetMediaAttachment[];
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meet-im/meet",
-  "version": "3.0.1",
+  "version": "3.2.1",
   "type": "module",
   "description": "OpenClaw Meet channel plugin",
   "scripts": {
@@ -55,7 +55,7 @@
     }
   },
   "dependencies": {
-    "@meet-im/meet-bot-jssdk": "1.0.0",
+    "@meet-im/meet-bot-jssdk": "^1.2.1",
     "zod": "^4.4.3"
   },
   "devDependencies": {