@meet-im/meet 3.2.4 → 3.3.0

package/dist/src/bot.js

@@ -239,9 +239,23 @@ export async function handleMeetMessage(params) {
         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()}${mentionsContext}${mediaContext}`
-            : (ctx.placeholder || "") + mentionsContext + mediaContext;
+        const quoteContext = ctx.replyContext?.content?.trim()
+            ? [
+                "Reply target of current user message (untrusted, for context):",
+                "```json",
+                JSON.stringify({
+                    body: ctx.replyContext.content.trim(),
+                    sender: ctx.replyContext.senderId,
+                    message_id: ctx.replyContext.messageId,
+                }, null, 2),
+                "```",
+                "",
+            ].join("\n")
+            : "";
+        const userBody = ctx.content.trim()
+            ? ctx.content.trim()
+            : (ctx.placeholder || "");
+        const finalContent = `${quoteContext}${userBody}${mentionsContext}${mediaContext}`;
         // Discord 做法：跳过空内容消息
         if (!finalContent.trim() && mediaPaths.length === 0) {
             log(`[${accountId}]: skip message ${ctx.messageId} (empty content)`);
@@ -367,6 +381,8 @@ export async function handleMeetMessage(params) {
         });
         const { createMeetReplyDispatcher } = await import("./reply-dispatcher.js");
         const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, route.agentId);
+        // 默认 typingMode 为 "instant"
+        const effectiveTypingMode = meetCfg.typingMode ?? "instant";
         const { dispatcher, replyOptions, markDispatchIdle, markRunComplete } = await createMeetReplyDispatcher({
             cfg,
             agentId: route.agentId,
@@ -377,6 +393,11 @@ export async function handleMeetMessage(params) {
             bot,
             botUserId,
             mediaLocalRoots,
+            // typing 相关参数
+            sessionInfo: ctx.sessionInfo,
+            apiToken: account.apiToken,
+            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}]: dispatching to AI agent=${route.agentId} session=${route.sessionKey} history=${inboundHistory?.length ?? 0}`);

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

@@ -46,6 +46,11 @@ export declare const MeetAccountConfigSchema: z.ZodObject<{
     dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
     textChunkLimit: z.ZodOptional<z.ZodNumber>;
     mediaMaxMb: z.ZodOptional<z.ZodNumber>;
+    typingMode: z.ZodOptional<z.ZodEnum<{
+        message: "message";
+        none: "none";
+        instant: "instant";
+    }>>;
     groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         name: z.ZodOptional<z.ZodString>;
@@ -106,6 +111,11 @@ export declare const MeetConfigSchema: z.ZodObject<{
     dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
     textChunkLimit: z.ZodOptional<z.ZodNumber>;
     mediaMaxMb: z.ZodOptional<z.ZodNumber>;
+    typingMode: z.ZodOptional<z.ZodEnum<{
+        message: "message";
+        none: "none";
+        instant: "instant";
+    }>>;
     accounts: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
         enabled: z.ZodOptional<z.ZodBoolean>;
         name: z.ZodOptional<z.ZodString>;
@@ -136,6 +146,11 @@ export declare const MeetConfigSchema: z.ZodObject<{
         dmHistoryLimit: z.ZodOptional<z.ZodNumber>;
         textChunkLimit: z.ZodOptional<z.ZodNumber>;
         mediaMaxMb: z.ZodOptional<z.ZodNumber>;
+        typingMode: z.ZodOptional<z.ZodEnum<{
+            message: "message";
+            none: "none";
+            instant: "instant";
+        }>>;
         groups: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodObject<{
             enabled: z.ZodOptional<z.ZodBoolean>;
             name: z.ZodOptional<z.ZodString>;

package/dist/src/config-schema.js

@@ -32,6 +32,7 @@ export const MeetAccountConfigSchema = z.object({
     dmHistoryLimit: z.number().min(0).optional(),
     textChunkLimit: z.number().min(1).optional(),
     mediaMaxMb: z.number().min(0).optional(),
+    typingMode: z.enum(["none", "instant", "message"]).optional(),
     groups: z.record(z.string(), MeetGroupConfigSchema).optional(),
 });
 export const MeetConfigSchema = z.object({
@@ -55,6 +56,7 @@ export const MeetConfigSchema = z.object({
     dmHistoryLimit: z.number().min(0).optional(),
     textChunkLimit: z.number().min(1).optional(),
     mediaMaxMb: z.number().min(0).optional(),
+    typingMode: z.enum(["none", "instant", "message"]).optional(),
     accounts: z.record(z.string(), MeetAccountConfigSchema).optional(),
 });
 export const MeetPluginConfigSchema = buildChannelConfigSchema(MeetConfigSchema);

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

@@ -1,2 +1,2 @@
-export declare const MEET_PLUGIN_VERSION = "3.2.4";
-export declare const MEET_OPENCLAW_VERSION = "2026.5.18";
+export declare const MEET_PLUGIN_VERSION = "3.3.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.2.4";
-export const MEET_OPENCLAW_VERSION = "2026.5.18";
+export const MEET_PLUGIN_VERSION = "3.3.0";
+export const MEET_OPENCLAW_VERSION = ">=2026.5.18";

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

@@ -1,4 +1,4 @@
-import type { MeetBot } from "@meet-im/meet-bot-jssdk";
+import type { MeetBot, SessionInfo } from "@meet-im/meet-bot-jssdk";
 import type { ClawdbotConfig, RuntimeEnv } from "openclaw/plugin-sdk";
 /**
  * 保护 mention 格式在分片后不被截断
@@ -20,6 +20,10 @@ export type CreateMeetReplyDispatcherOpts = {
     bot: MeetBot;
     botUserId: string;
     mediaLocalRoots?: readonly string[];
+    sessionInfo?: SessionInfo;
+    apiToken?: string;
+    apiEndpoint?: string;
+    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;

package/dist/src/reply-dispatcher.js

@@ -1,7 +1,9 @@
 import { resolveChannelSourceReplyDeliveryMode } from "openclaw/plugin-sdk/channel-reply-pipeline";
 import { createReplyPrefixContext } from "openclaw/plugin-sdk/channel-runtime";
+import { createTypingCallbacks } from "openclaw/plugin-sdk/channel-message";
 import { getMeetRuntime } from "./runtime.js";
 import { sendMessageMeet, sendMediaMeet } from "./send.js";
+import { sendTypingMeet, stopTypingMeet } from "./typing.js";
 function resolveMeetConversationType(chatId) {
     if (chatId.startsWith("channel:")) {
         return "group";
@@ -73,7 +75,7 @@ export function protectMentionsInChunks(chunks) {
     return result;
 }
 export async function createMeetReplyDispatcher(opts) {
-    const { cfg, agentId, chatId, replyToMessageId, accountId, mediaLocalRoots } = opts;
+    const { cfg, agentId, chatId, replyToMessageId, accountId, mediaLocalRoots, sessionInfo, apiToken, apiEndpoint, typingMode } = opts;
     const core = getMeetRuntime();
     const textChunkLimit = core.channel.text.resolveTextChunkLimit(cfg, "meet", accountId, {
         fallbackLimit: 4000,
@@ -87,6 +89,57 @@ export async function createMeetReplyDispatcher(opts) {
             ctx: { ChatType: chatType },
         })
         : undefined;
+    // 创建 typing callbacks（如果配置了 typing 且有必要参数）
+    const hasTypingParams = typingMode && typingMode !== "none" && sessionInfo && apiToken;
+    let typingRequestChain = Promise.resolve();
+    const enqueueTypingRequest = (label, run) => {
+        const next = typingRequestChain.then(async () => {
+            opts.runtime.log?.(`[${accountId}][${chatId}]: typing ${label} sending...`);
+            return await run();
+        });
+        typingRequestChain = next.then(() => undefined).catch(() => { });
+        return next;
+    };
+    const typingCallbacks = hasTypingParams
+        ? createTypingCallbacks({
+            start: async () => {
+                const result = await enqueueTypingRequest("start", async () => await sendTypingMeet({
+                    accountId,
+                    chatId,
+                    chatType: chatType ?? "channel",
+                    sessionInfo,
+                    token: apiToken,
+                    apiEndpoint,
+                }));
+                if (!result.ok && result.reason === "error") {
+                    throw result.error;
+                }
+                opts.runtime.log?.(`[${accountId}][${chatId}]: typing start sent ok=${result.ok}`);
+            },
+            stop: async () => {
+                await enqueueTypingRequest("stop", async () => await stopTypingMeet({
+                    accountId,
+                    chatId,
+                    chatType: chatType ?? "channel",
+                    sessionInfo,
+                    token: apiToken,
+                    apiEndpoint,
+                }));
+            },
+            onStartError: (err) => {
+                opts.runtime.error?.(`[${accountId}][${chatId}]: typing start failed: ${String(err)}`);
+            },
+            onStopError: (err) => {
+                opts.runtime.error?.(`[${accountId}][${chatId}]: typing stop failed: ${String(err)}`);
+            },
+        })
+        : undefined;
+    // instant 模式：立即启动 typing（不等 AI 开始响应）
+    if (typingMode === "instant" && typingCallbacks) {
+        void typingCallbacks.onReplyStart().catch((err) => {
+            opts.runtime.error?.(`[${accountId}][${chatId}]: instant typing start failed: ${String(err)}`);
+        });
+    }
     const { dispatcher, replyOptions, markDispatchIdle, markRunComplete } = core.channel.reply.createReplyDispatcherWithTyping({
         responsePrefix: prefixContext.responsePrefix,
         responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
@@ -96,7 +149,18 @@ export async function createMeetReplyDispatcher(opts) {
             conversationType: resolveMeetConversationType(chatId),
         },
         humanDelay: core.channel.reply.resolveHumanDelayConfig(cfg, agentId),
-        onReplyStart: async () => {
+        // instant 和 message 模式都传递 typingCallbacks（用于 onIdle/onCleanup）
+        typingCallbacks: typingCallbacks,
+        // instant 模式：首发已在外层手动触发，这里传空函数阻止 fallback
+        // message 模式：onReplyStart 在 AI 开始响应时触发
+        onReplyStart: typingCallbacks
+            ? typingMode === "instant"
+                ? async () => { } // 阻止 fallback，首发已手动触发
+                : async () => await typingCallbacks.onReplyStart()
+            : undefined,
+        onIdle: typingCallbacks?.onIdle,
+        onCleanup: () => {
+            typingCallbacks?.onCleanup?.();
         },
         deliver: async (payload, _info) => {
             opts.runtime.log?.(`[${accountId}]: reply deliver kind=${_info.kind} text_len=${payload.text?.length ?? 0} media_count=${payload.mediaUrls?.length ?? (payload.mediaUrl ? 1 : 0)} reasoning=${payload.isReasoning === true} error=${payload.isError === true}`);
@@ -192,8 +256,6 @@ export async function createMeetReplyDispatcher(opts) {
                 // 忽略错误消息发送失败
             }
         },
-        onIdle: async () => {
-        },
     });
     return {
         dispatcher,

package/dist/src/typing.d.ts

@@ -0,0 +1,24 @@
+import type { SessionInfo } from "@meet-im/meet-bot-jssdk";
+export type SendTypingParams = {
+    accountId: string;
+    chatId: string;
+    chatType: "direct" | "channel";
+    sessionInfo?: SessionInfo;
+    token?: string;
+    apiEndpoint?: string;
+};
+export type TypingResult = {
+    ok: true;
+} | {
+    ok: false;
+    reason: "unsupported" | "error";
+    error?: unknown;
+};
+/**
+ * 发送 typing 指示器
+ */
+export declare function sendTypingMeet(params: SendTypingParams): Promise<TypingResult>;
+/**
+ * 停止 typing 指示器
+ */
+export declare function stopTypingMeet(params: SendTypingParams): Promise<TypingResult>;

package/dist/src/typing.js

@@ -0,0 +1,44 @@
+import { sendUserTyping, TYPING_ACTION } from "@meet-im/meet-bot-jssdk";
+/**
+ * 发送 typing 指示器
+ */
+export async function sendTypingMeet(params) {
+    const { sessionInfo, token, apiEndpoint } = params;
+    // 缺少必要参数时返回 unsupported
+    if (!sessionInfo || !token) {
+        return { ok: false, reason: "unsupported" };
+    }
+    try {
+        await sendUserTyping({
+            token,
+            baseUrl: apiEndpoint,
+            sessionInfo,
+            action: TYPING_ACTION.TYPING,
+        });
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, reason: "error", error };
+    }
+}
+/**
+ * 停止 typing 指示器
+ */
+export async function stopTypingMeet(params) {
+    const { sessionInfo, token, apiEndpoint } = params;
+    if (!sessionInfo || !token) {
+        return { ok: false, reason: "unsupported" };
+    }
+    try {
+        await sendUserTyping({
+            token,
+            baseUrl: apiEndpoint,
+            sessionInfo,
+            action: TYPING_ACTION.STOPPED,
+        });
+        return { ok: true };
+    }
+    catch (error) {
+        return { ok: false, reason: "error", error };
+    }
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@meet-im/meet",
-  "version": "3.2.4",
+  "version": "3.3.0",
   "type": "module",
   "description": "OpenClaw Meet channel plugin",
   "scripts": {
@@ -55,7 +55,7 @@
     }
   },
   "dependencies": {
-    "@meet-im/meet-bot-jssdk": "^1.2.1",
+    "@meet-im/meet-bot-jssdk": "^1.3.0",
     "zod": "^4.4.3"
   },
   "devDependencies": {
@@ -68,7 +68,7 @@
     "vitest": "4.1.5"
   },
   "peerDependencies": {
-    "openclaw": "2026.5.18"
+    "openclaw": ">=2026.5.18"
   },
   "publishConfig": {
     "access": "public"