@chbo297/infoflow 2026.3.9 → 2026.3.14

package/CHANGELOG.md

@@ -1,5 +1,39 @@
 # Changelog
 
+## 2026.3.14
+
+### 新功能
+
+#### watchRegex 支持数组
+
+- `watchRegex` 可配置为字符串或字符串数组，支持多条正则；命中任一条即触发回复判断。
+
+#### Markdown 本地图片
+
+- 回复内容中的本地图片 URL（`/`、`./`、`file://` 等）会解析并转为 base64，以如流图片消息形式发送，避免链接不可访问。
+
+### 优化
+
+#### follow-up（跟进回复）判定逻辑
+
+- 机器人更智能地判断是否在跟进窗口内回复——
+  - **提高回复倾向**：当发言者表现出期望得到回应的意愿（例如追问、延续同一话题）时，增加机器人回复的可能性；
+  - **降低回复倾向**：当发言者明确禁止机器人回复（例如「不用回了」「别回复」等）时，降低机器人回复的可能性。
+
+### Bug 修复
+
+- 修复消息分片发送时顺序错乱的问题。
+
+---
+
+## 2026.3.10
+
+### Bug 修复
+
+- 修复来自 bot 的消息处理逻辑（避免对机器人自身消息错误响应）。
+
+---
+
 ## 2026.3.8
 
 ### 新功能

package/README.md

@@ -19,6 +19,7 @@
 - **按群独立配置**：每个群可设置不同的回复策略和系统提示词
 - **多账号支持**：一个实例管理多个如流机器人
 - **Agent 主动/定时发送**：LLM Agent 可主动或定时发送私聊消息、往群里发消息，支持 @指定用户或 @全员
+- **Markdown 本地图片**：回复内容中的本地图片路径会自动转为图片消息发送
 
 ## 安装
 
@@ -102,16 +103,16 @@ https://your-domain/webhook/infoflow
 
 ## 正则匹配 (watchRegex)
 
-通过正则表达式匹配群内聊天内容，当消息文本命中正则时，会触发机器人参与并回复（需配合 `replyMode` 为 `mention-and-watch` 或 `proactive`）。可在顶层、账号或按群单独配置。
+通过正则表达式匹配群内聊天内容，当消息文本命中任一正则时，会触发机器人参与并回复（需配合 `replyMode` 为 `mention-and-watch` 或 `proactive`）。`watchRegex` 可配置为**字符串**或**字符串数组**（多条正则，命中其一即触发）。可在顶层、账号或按群单独配置。
 
 ```json5
 {
   channels: {
     infoflow: {
-      watchRegex: "^(帮忙|请帮我|求助)",  // 顶层：匹配以这些词开头的消息
+      watchRegex: ["^(帮忙|请帮我)", "\\?$"],  // 顶层：数组形式，多条正则
       groups: {
         "123456": {
-          watchRegex: "\\?$|怎么|如何",   // 该群：匹配以问号结尾或含「怎么」「如何」的消息
+          watchRegex: "\\?$|怎么|如何",   // 该群：单条正则，匹配以问号结尾或含「怎么」「如何」的消息
         },
       },
     },
@@ -234,7 +235,7 @@ https://your-domain/webhook/infoflow
 | `followUp` | `boolean` | `true` | 是否启用跟进回复 |
 | `followUpWindow` | `number` | `300` | 跟进窗口（秒） |
 | `watchMentions` | `string[]` | `[]` | 关注提及的人员列表 |
-| `watchRegex` | `string` | — | 正则表达式，匹配群消息内容时触发回复 |
+| `watchRegex` | `string` \| `string[]` | — | 正则或正则数组，匹配群消息内容时触发回复 |
 | `dmPolicy` | `string` | `"open"` | 私聊策略 |
 | `allowFrom` | `string[]` | `[]` | 私聊白名单 |
 | `groupPolicy` | `string` | `"open"` | 群聊策略 |
@@ -249,7 +250,7 @@ https://your-domain/webhook/infoflow
 |------|------|------|
 | `replyMode` | `string` | 覆盖该群的回复模式 |
 | `watchMentions` | `string[]` | 覆盖该群的关注列表 |
-| `watchRegex` | `string` | 覆盖该群的正则匹配规则，匹配群消息内容时触发回复 |
+| `watchRegex` | `string` \| `string[]` | 覆盖该群的正则匹配规则（可为单条或数组），匹配群消息内容时触发回复 |
 | `followUp` | `boolean` | 覆盖该群的跟进开关 |
 | `followUpWindow` | `number` | 覆盖该群的跟进窗口 |
 | `systemPrompt` | `string` | 该群专属系统提示词 |
@@ -289,6 +290,7 @@ Baidu Infoflow (如流) enterprise messaging platform — OpenClaw channel plugi
 - **Per-group config**: each group can have its own reply strategy and system prompt
 - **Multi-account support**: manage multiple Infoflow bots from a single instance
 - **Agent-initiated / scheduled sending**: LLM Agent can proactively or on a schedule send DMs, post messages to groups, @specific users, or @all members
+- **Markdown local images**: local image paths in reply content are converted and sent as image messages
 
 ## Install
 
@@ -372,16 +374,16 @@ Configure a list of people to watch. When someone in the group @mentions a perso
 
 ## Regex Match (watchRegex)
 
-Match group chat content with a regular expression; when a message matches, the bot is triggered to participate and reply (requires `replyMode` `mention-and-watch` or `proactive`). Can be set at top level, per account, or per group.
+Match group chat content with a regular expression; when a message matches any pattern, the bot is triggered to participate and reply (requires `replyMode` `mention-and-watch` or `proactive`). `watchRegex` can be a **string** or **string array** (multiple patterns; any match triggers). Can be set at top level, per account, or per group.
 
 ```json5
 {
   channels: {
     infoflow: {
-      watchRegex: "^(help|please|urgent)",  // Top-level: match messages starting with these
+      watchRegex: ["^(help|please)", "\\?$"],  // Top-level: array of patterns
       groups: {
         "123456": {
-          watchRegex: "\\?$|how to|what is",  // This group: match messages ending with ? or containing "how to"/"what is"
+          watchRegex: "\\?$|how to|what is",  // This group: single pattern
         },
       },
     },
@@ -504,7 +506,7 @@ Set independent reply strategies for each group, overriding the global defaults.
 | `followUp` | `boolean` | `true` | Enable follow-up replies |
 | `followUpWindow` | `number` | `300` | Follow-up window (seconds) |
 | `watchMentions` | `string[]` | `[]` | List of people to watch for @mentions |
-| `watchRegex` | `string` | — | Regex to match group message content; when matched, trigger reply |
+| `watchRegex` | `string` \| `string[]` | — | Regex or array of regexes; when matched, trigger reply |
 | `dmPolicy` | `string` | `"open"` | DM access policy |
 | `allowFrom` | `string[]` | `[]` | DM allowlist |
 | `groupPolicy` | `string` | `"open"` | Group access policy |
@@ -519,7 +521,7 @@ Set independent reply strategies for each group, overriding the global defaults.
 |-------|------|-------------|
 | `replyMode` | `string` | Override reply mode for this group |
 | `watchMentions` | `string[]` | Override watch list for this group |
-| `watchRegex` | `string` | Override regex for this group; match group content to trigger reply |
+| `watchRegex` | `string` \| `string[]` | Override regex for this group (single or array); match group content to trigger reply |
 | `followUp` | `boolean` | Override follow-up toggle for this group |
 | `followUpWindow` | `number` | Override follow-up window for this group |
 | `systemPrompt` | `string` | Custom system prompt for this group |

package/openclaw.plugin.json

@@ -30,7 +30,7 @@
       "followUp": { "type": "boolean", "default": true },
       "followUpWindow": { "type": "number", "default": 300 },
       "watchMentions": { "type": "array", "items": { "type": "string" } },
-      "watchRegex": { "type": "string" },
+      "watchRegex": { "type": "array", "items": { "type": "string" } },
       "groups": {
         "type": "object",
         "additionalProperties": {
@@ -41,7 +41,7 @@
               "enum": ["ignore", "record", "mention-only", "mention-and-watch", "proactive"]
             },
             "watchMentions": { "type": "array", "items": { "type": "string" } },
-            "watchRegex": { "type": "string" },
+            "watchRegex": { "type": "array", "items": { "type": "string" } },
             "followUp": { "type": "boolean" },
             "followUpWindow": { "type": "number" },
             "systemPrompt": { "type": "string" }
@@ -77,7 +77,7 @@
             "followUp": { "type": "boolean" },
             "followUpWindow": { "type": "number" },
             "watchMentions": { "type": "array", "items": { "type": "string" } },
-            "watchRegex": { "type": "string" },
+            "watchRegex": { "type": "array", "items": { "type": "string" } },
             "groups": {
               "type": "object",
               "additionalProperties": {
@@ -88,7 +88,7 @@
                     "enum": ["ignore", "record", "mention-only", "mention-and-watch", "proactive"]
                   },
                   "watchMentions": { "type": "array", "items": { "type": "string" } },
-                  "watchRegex": { "type": "string" },
+                  "watchRegex": { "type": "array", "items": { "type": "string" } },
                   "followUp": { "type": "boolean" },
                   "followUpWindow": { "type": "number" },
                   "systemPrompt": { "type": "string" }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@chbo297/infoflow",
-  "version": "2026.3.9",
+  "version": "2026.3.14",
   "description": "OpenClaw Infoflow (如流) channel plugin for Baidu enterprise messaging",
   "type": "module",
   "main": "index.ts",

package/src/accounts.ts

@@ -71,7 +71,7 @@ function mergeInfoflowAccountConfig(
   robotName?: string;
   requireMention?: boolean;
   watchMentions?: string[];
-  watchRegex?: string;
+  watchRegex?: string | string[];
   appAgentId?: number;
 } {
   const raw = getChannelSection(cfg) ?? {};
@@ -88,11 +88,16 @@ function mergeInfoflowAccountConfig(
     robotName?: string;
     requireMention?: boolean;
     watchMentions?: string[];
-    watchRegex?: string;
+    watchRegex?: string | string[];
     appAgentId?: number;
   };
 }
 
+function normalizeWatchRegex(v: string | string[] | undefined): string[] {
+  if (v == null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+
 // ---------------------------------------------------------------------------
 // Account Resolution
 // ---------------------------------------------------------------------------
@@ -133,7 +138,7 @@ export function resolveInfoflowAccount(params: {
       robotName: merged.robotName?.trim() || undefined,
       requireMention: merged.requireMention,
       watchMentions: merged.watchMentions,
-      watchRegex: merged.watchRegex,
+      watchRegex: normalizeWatchRegex(merged.watchRegex),
       appAgentId: merged.appAgentId,
     },
   };

package/src/actions.ts

@@ -372,54 +372,56 @@ export const infoflowMessageActions: ChannelMessageActionAdapter = {
         `[infoflow:action:send] to=${to}, atAll=${atAll}, mentionUserIds=${mentionUserIdsRaw ?? "none"}`,
       );
 
-      // Send text+mentions first (if any)
-      if (contents.length > 0) {
-        await sendInfoflowMessage({
-          cfg,
-          to,
-          contents,
-          accountId: accountId ?? undefined,
-          replyTo,
-        });
-      }
-
-      // Try native image send, fallback to link
+      // b-mode: fire text first (if any), then image/link, then await all
+      const p1 =
+        contents.length > 0
+          ? sendInfoflowMessage({
+              cfg,
+              to,
+              contents,
+              accountId: accountId ?? undefined,
+              replyTo,
+            })
+          : null;
+      let p2: Promise<{ ok: boolean; messageId?: string; error?: string }>;
       try {
         const prepared = await prepareInfoflowImageBase64({ mediaUrl });
         if (prepared.isImage) {
-          const imgResult = await sendInfoflowImageMessage({
+          p2 = sendInfoflowImageMessage({
             cfg,
             to,
             base64Image: prepared.base64,
             accountId: accountId ?? undefined,
             replyTo: contents.length > 0 ? undefined : replyTo,
           });
-          return jsonResult({
-            ok: imgResult.ok,
-            channel: "infoflow",
+        } else {
+          p2 = sendInfoflowMessage({
+            cfg,
             to,
-            messageId: imgResult.messageId ?? (imgResult.ok ? "sent" : "failed"),
-            ...(imgResult.error ? { error: imgResult.error } : {}),
+            contents: [{ type: "link", content: mediaUrl }],
+            accountId: accountId ?? undefined,
+            replyTo: contents.length > 0 ? undefined : replyTo,
           });
         }
       } catch {
-        // fallback to link below
+        p2 = sendInfoflowMessage({
+          cfg,
+          to,
+          contents: [{ type: "link", content: mediaUrl }],
+          accountId: accountId ?? undefined,
+          replyTo: contents.length > 0 ? undefined : replyTo,
+        });
       }
-
-      // Non-image or native send failed → send as link
-      const linkResult = await sendInfoflowMessage({
-        cfg,
-        to,
-        contents: [{ type: "link", content: mediaUrl }],
-        accountId: accountId ?? undefined,
-        replyTo: contents.length > 0 ? undefined : replyTo,
-      });
+      const results = await Promise.all([p1, p2].filter(Boolean));
+      const last = results.at(-1) as
+        | { ok: boolean; messageId?: string; error?: string }
+        | undefined;
       return jsonResult({
-        ok: linkResult.ok,
+        ok: last?.ok ?? false,
         channel: "infoflow",
         to,
-        messageId: linkResult.messageId ?? (linkResult.ok ? "sent" : "failed"),
-        ...(linkResult.error ? { error: linkResult.error } : {}),
+        messageId: last?.messageId ?? (last?.ok ? "sent" : "failed"),
+        ...(last?.error ? { error: last.error } : {}),
       });
     }
 

package/src/bot.ts

@@ -6,10 +6,12 @@ import {
   recordPendingHistoryEntryIfEnabled,
   buildAgentMediaPayload,
 } from "openclaw/plugin-sdk";
+import { getAgentScopedMediaLocalRoots } from "../../../src/media/local-roots.js";
 import { resolveInfoflowAccount } from "./accounts.js";
 import { getInfoflowBotLog, formatInfoflowError, logVerbose } from "./logging.js";
 import { createInfoflowReplyDispatcher } from "./reply-dispatcher.js";
 import { getInfoflowRuntime } from "./runtime.js";
+import { findSentMessage } from "./sent-message-store.js";
 import type {
   InfoflowChatType,
   InfoflowMessageEvent,
@@ -46,6 +48,8 @@ type InfoflowBodyItem = {
   userid?: string;
   /** IMAGE 类型 body item 的图片下载地址 */
   downloadurl?: string;
+  /** replyData 类型 body item 中被引用消息的 ID */
+  messageid?: string | number;
 };
 
 /**
@@ -103,13 +107,35 @@ function checkWatchMentioned(
   return undefined;
 }
 
-/** Check if message content matches the configured watchRegex regex pattern. Uses "s" (dotAll) so that . matches newlines in multi-line messages. */
-function checkWatchRegex(mes: string, pattern: string): boolean {
-  try {
-    return new RegExp(pattern, "is").test(mes);
-  } catch {
-    return false;
+/** Normalize watchRegex config to string[] (supports legacy single string). */
+function normalizeWatchRegex(v: string | string[] | undefined): string[] {
+  if (v == null) return [];
+  return Array.isArray(v) ? v : [v];
+}
+
+/** Check if message content matches any of the configured watchRegex patterns. Uses "s" (dotAll) so that . matches newlines. */
+function checkWatchRegex(mes: string, patterns: string[]): boolean {
+  if (!patterns.length) return false;
+  for (const pattern of patterns) {
+    try {
+      if (new RegExp(pattern, "is").test(mes)) return true;
+    } catch {
+      // skip invalid pattern
+    }
+  }
+  return false;
+}
+
+/** Return the first matching pattern index, or -1 if none match. Used for triggerReason and prompt. */
+function findMatchingWatchRegex(mes: string, patterns: string[]): number {
+  for (let i = 0; i < patterns.length; i++) {
+    try {
+      if (new RegExp(patterns[i], "is").test(mes)) return i;
+    } catch {
+      // skip invalid pattern
+    }
   }
+  return -1;
 }
 
 /**
@@ -144,6 +170,37 @@ function extractMentionIds(bodyItems: InfoflowBodyItem[], robotName?: string): I
   return { userIds, agentIds };
 }
 
+/** Check if the message @mentions other bots or human users (excluding the bot itself). */
+function hasOtherMentions(mentionIds?: InfoflowMentionIds): boolean {
+  if (!mentionIds) return false;
+  return mentionIds.userIds.length > 0 || mentionIds.agentIds.length > 0;
+}
+
+// ---------------------------------------------------------------------------
+// Reply-to-bot detection (引用回复机器人消息)
+// ---------------------------------------------------------------------------
+
+/**
+ * Check if the message is a reply (引用回复) to one of the bot's own messages.
+ * Looks up replyData body items' messageid against the sent-message-store.
+ */
+function checkReplyToBot(bodyItems: InfoflowBodyItem[], accountId: string): boolean {
+  for (const item of bodyItems) {
+    if (item.type !== "replyData") continue;
+    const msgId = item.messageid;
+    if (msgId == null) continue;
+    const msgIdStr = String(msgId);
+    if (!msgIdStr) continue;
+    try {
+      const found = findSentMessage(accountId, msgIdStr);
+      if (found) return true;
+    } catch {
+      // DB lookup failure should not block message processing
+    }
+  }
+  return false;
+}
+
 // ---------------------------------------------------------------------------
 // Shared reply judgment rules (reused across prompt builders)
 // ---------------------------------------------------------------------------
@@ -151,26 +208,32 @@ function extractMentionIds(bodyItems: InfoflowBodyItem[], robotName?: string): I
 /** Shared judgment rules and reply format requirements for all conditional-reply prompts */
 function buildReplyJudgmentRules(): string {
   return [
-    "# Rules",
+    "# Rules for Group Message Response",
     "",
-    "## Can answer or help → Reply directly",
+    "## When to Reply",
     "",
-    "Reply if ANY of these apply:",
-    "- The question can be answered through common sense or logical reasoning (e.g. math, general knowledge)",
-    "- You can find relevant clues or content in your knowledge base, documentation, or code",
-    "- You have sufficient domain expertise to provide a valuable reference",
+    "Reply if ANY of the following is true:",
+    "- The message is directed at you — either by explicit mention, or by contextual signals suggesting the user expects your response (e.g., a question following your previous reply, a topic clearly within your role, or conversational flow implying you are the intended recipient)",
+    "- The message contains a clear question or request that you can answer using your knowledge, skills, tools, or reasoning",
+    "- You have relevant domain expertise, documentation, or codebase context that adds value",
     "",
-    "## Cannot answer → Reply with NO_REPLY only",
+    "## When NOT to Reply — output only `NO_REPLY`",
     "",
-    "Do NOT reply if ANY of these apply:",
-    "- The message contains no clear question or request (e.g. casual chat, meaningless content)",
-    "- The question involves private information or context you have no knowledge of",
-    "- You cannot understand the core intent of the message",
+    "Do NOT reply if ANY of the following is true:",
+    "- The message is casual chatter, banter, emoji-only, or has no actionable question/request",
+    "- The user explicitly indicates they don't want your response",
+    "- The message is directed at another person, not at you",
+    "- You lack the context or knowledge to give a useful answer (e.g., private/internal info you don't have access to)",
+    "- The message intent is ambiguous and a wrong guess would be more disruptive than silence",
     "",
-    "# Response format",
+    "## Response Format",
     "",
-    "- When you can answer: give a direct, concise answer. Do not explain why you chose to answer.",
-    "- When you cannot answer: output only NO_REPLY with no other text.",
+    "- If you can answer: respond directly and concisely. Do not explain why you chose to answer. Do not add filler or pleasantries.",
+    "- If you cannot answer: output exactly `NO_REPLY` — nothing else, no explanation, no apology.",
+    "",
+    "## Guiding Principle",
+    "",
+    "When in doubt, prefer silence (`NO_REPLY`). A missing reply is far less disruptive than an irrelevant or incorrect one in a group chat.",
   ].join("\n");
 }
 
@@ -207,9 +270,10 @@ function buildWatchMentionPrompt(mentionedId: string): string {
  * Build a GroupSystemPrompt for watch-content triggered messages.
  * Instructs the agent to reply only when confident, otherwise use NO_REPLY.
  */
-function buildWatchRegexPrompt(pattern: string): string {
+function buildWatchRegexPrompt(patterns: string[]): string {
+  const label = patterns.length ? `(${patterns.join(" | ")})` : "";
   return [
-    `The message content matched the configured watch pattern (${pattern}).`,
+    `The message content matched one of the configured watch patterns ${label}.`,
     "As the group assistant, you observed this message. Decide whether you can provide help or a valuable reply.",
     "",
     buildReplyJudgmentRules(),
@@ -218,14 +282,60 @@ function buildWatchRegexPrompt(pattern: string): string {
 
 /**
  * Build a GroupSystemPrompt for follow-up replies after bot's last response.
- * Instructs the agent to reply only if the message is a follow-up on the same topic.
+ * Uses three-tier semantic priority: (1) intent to talk to bot → must reply,
+ * (2) explicit stop request → must not reply, (3) topic continuity judgment.
+ *
+ * When isReplyToBot is true, injects a strong signal that the user quoted the bot's message.
  */
-function buildFollowUpPrompt(): string {
-  return [
+function buildFollowUpPrompt(isReplyToBot: boolean): string {
+  const lines: string[] = [
     "You just replied to a message in this group. Someone has now sent a new message.",
-    "First determine if this message is a follow-up or continuation of the same topic you previously replied to, then decide if you can continue to help.",
+    "Follow the priority rules below **in order** to decide whether to reply.",
     "",
-    "Note: If this message is clearly a new topic or unrelated to your previous reply, respond with NO_REPLY.",
+  ];
+
+  if (isReplyToBot) {
+    lines.push(
+      "**Important context: this message is a quoted reply to your previous message. This is a strong signal that the user is following up with you.**",
+      "",
+    );
+  }
+
+  lines.push(
+    "# Priority 1: The sender intends to talk to you → MUST reply",
+    "",
+    "Based on semantic analysis, if the sender shows ANY of the following intents or expectations, you **MUST** reply (do NOT output NO_REPLY):",
+    "- Asking a follow-up question about your previous answer (e.g. 'why?', 'what else?', 'what if...?')",
+    "- Quoted/replied to your message (indicating a conversation with you)",
+    "- Addressing you by name, or using words like 'bot', 'assistant', etc.",
+    "- Requesting you to do something (e.g. 'help me...', 'explain...', 'translate...')",
+    "- Semantically expects a reply from you",
+    "",
+    "# Priority 2: Explicitly asking you to stop → MUST NOT reply",
+    "",
+    "If the message explicitly tells you to stop replying (e.g. 'shut up', 'stop', 'don't reply',",
+    "'no need for bot', or equivalent expressions in any language),",
+    "output only NO_REPLY.",
+    "",
+    "# Priority 3: No explicit intent → Judge topic continuity",
+    "",
+    "If neither Priority 1 nor Priority 2 applies:",
+    "- If the message continues the same topic you previously replied to, and you can provide valuable help → reply.",
+    "- If it is a new/unrelated topic, or you cannot add value → output only NO_REPLY.",
+    "",
+    buildReplyJudgmentRules(),
+  );
+
+  return lines.join("\n");
+}
+
+/**
+ * Build a GroupSystemPrompt for follow-up messages that @mention another person or bot.
+ * Uses the conservative ReplyJudgmentRules since the message is likely directed at someone else.
+ */
+function buildFollowUpOtherMentionedPrompt(): string {
+  return [
+    "You recently replied in this group. A new message has arrived, but it @mentions another person or bot — it is likely directed at them, not at you.",
     "",
     buildReplyJudgmentRules(),
   ].join("\n");
@@ -275,7 +385,7 @@ type ResolvedGroupConfig = {
   followUp: boolean;
   followUpWindow: number;
   watchMentions: string[];
-  watchRegex?: string;
+  watchRegex: string[];
   systemPrompt?: string;
 };
 
@@ -300,7 +410,7 @@ function resolveGroupConfig(
     followUp: groupCfg?.followUp ?? account.config.followUp ?? true,
     followUpWindow: groupCfg?.followUpWindow ?? account.config.followUpWindow ?? 300,
     watchMentions: groupCfg?.watchMentions ?? account.config.watchMentions ?? [],
-    watchRegex: groupCfg?.watchRegex ?? account.config.watchRegex,
+    watchRegex: normalizeWatchRegex(groupCfg?.watchRegex ?? account.config.watchRegex),
     systemPrompt: groupCfg?.systemPrompt,
   };
 }
@@ -373,11 +483,15 @@ export async function handlePrivateChatMessage(params: HandlePrivateChatParams):
 export async function handleGroupChatMessage(params: HandleGroupChatParams): Promise<void> {
   const { cfg, msgData, accountId, statusSink } = params;
 
-  // Extract sender from nested structure or flat fields
+  // Extract sender from nested structure or flat fields.
+  // Some Infoflow events (including bot-authored forwards) only populate `fromid` on the root,
+  // so include msgData.fromid as a final fallback.
   const header = (msgData.message as Record<string, unknown>)?.header as
     | Record<string, unknown>
     | undefined;
-  const fromuser = String(header?.fromuserid ?? msgData.fromuserid ?? msgData.from ?? "");
+  const fromuser = String(
+    header?.fromuserid ?? msgData.fromuserid ?? msgData.from ?? msgData.fromid ?? "",
+  );
 
   // Extract message ID (priority: header.messageid > header.msgid > MsgId)
   const messageId = header?.messageid ?? header?.msgid ?? msgData.MsgId;
@@ -426,7 +540,7 @@ export async function handleGroupChatMessage(params: HandleGroupChatParams): Pro
         if (replyBody) {
           replyContextItems.push(replyBody);
         }
-      } else if (item.type === "TEXT") {
+      } else if (item.type === "TEXT" || item.type === "MD") {
         textContent += item.content ?? "";
         rawTextContent += item.content ?? "";
       } else if (item.type === "LINK") {
@@ -447,6 +561,10 @@ export async function handleGroupChatMessage(params: HandleGroupChatParams): Pro
         if (typeof url === "string" && url.trim()) {
           imageUrls.push(url.trim());
         }
+      } else if (typeof item.content === "string" && item.content.trim()) {
+        // Fallback: for any other item types with string content, treat content as text.
+        textContent += item.content;
+        rawTextContent += item.content;
       }
     }
   }
@@ -471,6 +589,9 @@ export async function handleGroupChatMessage(params: HandleGroupChatParams): Pro
   // Extract sender name from header or fallback to fromuser
   const senderName = String(header?.username ?? header?.nickname ?? msgData.username ?? fromuser);
 
+  // Detect reply-to-bot: check if any replyData item quotes a bot-sent message
+  const isReplyToBot = replyContext ? checkReplyToBot(bodyItems, accountId) : false;
+
   // Delegate to the common message handler (group chat)
   await handleInfoflowMessage({
     cfg,
@@ -488,6 +609,7 @@ export async function handleGroupChatMessage(params: HandleGroupChatParams): Pro
       mentionIds:
         mentionIds.userIds.length > 0 || mentionIds.agentIds.length > 0 ? mentionIds : undefined,
       replyContext,
+      isReplyToBot: isReplyToBot || undefined,
       imageUrls: imageUrls.length > 0 ? imageUrls : undefined,
     },
     accountId,
@@ -736,8 +858,13 @@ export async function handleInfoflowMessage(params: HandleInfoflowMessageParams)
           groupIdStr &&
           isWithinFollowUpWindow(groupIdStr, groupCfg.followUpWindow)
         ) {
-          triggerReason = "followUp";
-          ctxPayload.GroupSystemPrompt = buildFollowUpPrompt();
+          if (hasOtherMentions(event.mentionIds)) {
+            triggerReason = "followUp-other-mentioned";
+            ctxPayload.GroupSystemPrompt = buildFollowUpOtherMentionedPrompt();
+          } else {
+            triggerReason = "followUp";
+            ctxPayload.GroupSystemPrompt = buildFollowUpPrompt(event.isReplyToBot === true);
+          }
         } else {
           if (groupIdStr) {
             logVerbose(
@@ -770,18 +897,26 @@ export async function handleInfoflowMessage(params: HandleInfoflowMessageParams)
           triggerReason = `watchMentions(${matchedWatchId})`;
           // Watch-mention triggered: instruct agent to reply only if confident
           ctxPayload.GroupSystemPrompt = buildWatchMentionPrompt(matchedWatchId);
-        } else if (groupCfg.watchRegex && checkWatchRegex(mes, groupCfg.watchRegex)) {
-          triggerReason = `watchRegex(${groupCfg.watchRegex})`;
-          // Watch-content triggered: message matched configured regex pattern
+        } else if (groupCfg.watchRegex.length > 0 && checkWatchRegex(mes, groupCfg.watchRegex)) {
+          const idx = findMatchingWatchRegex(mes, groupCfg.watchRegex);
+          triggerReason =
+            idx >= 0
+              ? `watchRegex(${groupCfg.watchRegex[idx]})`
+              : `watchRegex(${groupCfg.watchRegex.join("|")})`;
+          // Watch-content triggered: message matched one of the configured regex patterns
           ctxPayload.GroupSystemPrompt = buildWatchRegexPrompt(groupCfg.watchRegex);
         } else if (
           groupCfg.followUp &&
           groupIdStr &&
           isWithinFollowUpWindow(groupIdStr, groupCfg.followUpWindow)
         ) {
-          triggerReason = "followUp";
-          // Follow-up window: let LLM decide if this is a follow-up
-          ctxPayload.GroupSystemPrompt = buildFollowUpPrompt();
+          if (hasOtherMentions(event.mentionIds)) {
+            triggerReason = "followUp-other-mentioned";
+            ctxPayload.GroupSystemPrompt = buildFollowUpOtherMentionedPrompt();
+          } else {
+            triggerReason = "followUp";
+            ctxPayload.GroupSystemPrompt = buildFollowUpPrompt(event.isReplyToBot === true);
+          }
         } else {
           if (groupIdStr) {
             logVerbose(
@@ -862,6 +997,7 @@ export async function handleInfoflowMessage(params: HandleInfoflowMessageParams)
     // Pass inbound messageId for outbound reply-to (group only)
     replyToMessageId: isGroup ? event.messageId : undefined,
     replyToPreview: isGroup ? mes : undefined,
+    mediaLocalRoots: getAgentScopedMediaLocalRoots(cfg, route.agentId),
   });
 
   const dispatchResult = await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
@@ -904,3 +1040,9 @@ export const _checkWatchMentioned = checkWatchMentioned;
 
 /** @internal — Extract non-bot mention IDs. Only exported for tests. */
 export const _extractMentionIds = extractMentionIds;
+
+/** @internal — Check if message matches any watchRegex pattern (dotAll). Only exported for tests. */
+export const _checkWatchRegex = checkWatchRegex;
+
+/** @internal — Check if message is a reply to one of the bot's own messages. Only exported for tests. */
+export const _checkReplyToBot = checkReplyToBot;

package/src/channel.ts

@@ -17,12 +17,13 @@ import {
 } from "./accounts.js";
 import { infoflowMessageActions } from "./actions.js";
 import { logVerbose } from "./logging.js";
+import { parseMarkdownForLocalImages } from "./markdown-local-images.js";
 import { prepareInfoflowImageBase64, sendInfoflowImageMessage } from "./media.js";
 import { startInfoflowMonitor } from "./monitor.js";
 import { getInfoflowRuntime } from "./runtime.js";
 import { sendInfoflowMessage } from "./send.js";
 import { normalizeInfoflowTarget, looksLikeInfoflowId } from "./targets.js";
-import type { ResolvedInfoflowAccount } from "./types.js";
+import type { InfoflowOutboundReply, ResolvedInfoflowAccount } from "./types.js";
 
 // Re-export types and account functions for external consumers
 export type { InfoflowAccountConfig, ResolvedInfoflowAccount } from "./types.js";
@@ -209,19 +210,84 @@ export const infoflowPlugin: ChannelPlugin<ResolvedInfoflowAccount> = {
     chunkerMode: "markdown",
     textChunkLimit: 2048,
     chunker: (text, limit) => getInfoflowRuntime().channel.text.chunkText(text, limit),
-    sendText: async ({ cfg, to, text, accountId }) => {
+    sendText: async ({ cfg, to, text, accountId, mediaLocalRoots, replyToId }) => {
       logVerbose(`[infoflow:sendText] to=${to}, accountId=${accountId}`);
-      // Use "markdown" type even though param is named `text`: LLM outputs are often markdown,
-      // and Infoflow's markdown type handles both plain text and markdown seamlessly.
-      const result = await sendInfoflowMessage({
-        cfg,
-        to,
-        contents: [{ type: "markdown", content: text }],
-        accountId: accountId ?? undefined,
-      });
+      const isGroup = /^group:\d+$/i.test(to.replace(/^infoflow:/i, ""));
+      const replyTo: InfoflowOutboundReply | undefined =
+        isGroup && replyToId?.trim() ? { messageid: replyToId.trim(), preview: "" } : undefined;
+
+      const segments = parseMarkdownForLocalImages(text);
+      let replyApplied = false;
+      const sendPromises: Promise<{ ok?: boolean; messageId?: string }>[] = [];
+
+      for (const segment of segments) {
+        if (segment.type === "text") {
+          const content = segment.content.trim();
+          if (!content) continue;
+          sendPromises.push(
+            sendInfoflowMessage({
+              cfg,
+              to,
+              contents: [{ type: "markdown", content: segment.content }],
+              accountId: accountId ?? undefined,
+              replyTo: replyApplied ? undefined : replyTo,
+            }),
+          );
+          replyApplied = true;
+          continue;
+        }
+        // segment.type === "image"
+        try {
+          const prepared = await prepareInfoflowImageBase64({
+            mediaUrl: segment.content,
+            mediaLocalRoots: mediaLocalRoots ?? undefined,
+          });
+          if (prepared.isImage) {
+            sendPromises.push(
+              sendInfoflowImageMessage({
+                cfg,
+                to,
+                base64Image: prepared.base64,
+                accountId: accountId ?? undefined,
+                replyTo: replyApplied ? undefined : replyTo,
+              }),
+            );
+            replyApplied = true;
+          } else {
+            sendPromises.push(
+              sendInfoflowMessage({
+                cfg,
+                to,
+                contents: [{ type: "link", content: segment.content }],
+                accountId: accountId ?? undefined,
+                replyTo: replyApplied ? undefined : replyTo,
+              }),
+            );
+            replyApplied = true;
+          }
+        } catch (err) {
+          logVerbose(`[infoflow:sendText] image prep failed, sending as link: ${err}`);
+          sendPromises.push(
+            sendInfoflowMessage({
+              cfg,
+              to,
+              contents: [{ type: "link", content: segment.content }],
+              accountId: accountId ?? undefined,
+              replyTo: replyApplied ? undefined : replyTo,
+            }),
+          );
+          replyApplied = true;
+        }
+      }
+
+      if (sendPromises.length === 0) {
+        return { channel: "infoflow", messageId: "failed" };
+      }
+      const results = await Promise.all(sendPromises);
+      const lastOk = results.filter((r) => r?.ok).at(-1);
       return {
         channel: "infoflow",
-        messageId: result.ok ? (result.messageId ?? "sent") : "failed",
+        messageId: lastOk ? (lastOk.messageId ?? "sent") : "failed",
       };
     },
     sendMedia: async ({ cfg, to, text, mediaUrl, accountId, mediaLocalRoots }) => {
@@ -272,9 +338,11 @@ export const infoflowPlugin: ChannelPlugin<ResolvedInfoflowAccount> = {
         return { ok: linkResult.ok, messageId: linkResult.messageId };
       };
 
-      // Dispatch: concurrent text + image, or text-only, or image-only
+      // b-mode: fire in upstream order (caption first, then media), then await all
       if (trimmedText && mediaUrl) {
-        const [, imageResult] = await Promise.all([sendText(), sendImage()]);
+        const p1 = sendText();
+        const p2 = sendImage();
+        const [, imageResult] = await Promise.all([p1, p2]);
         return {
           channel: "infoflow",
           messageId: imageResult.ok ? (imageResult.messageId ?? "sent") : "failed",

package/src/markdown-local-images.ts

@@ -0,0 +1,75 @@
+/**
+ * Parses markdown for local image links and splits content into ordered segments
+ * (text or image URL) so the channel can send text + image + text as separate messages.
+ */
+
+function isLocalPath(url: string): boolean {
+  const trimmed = url.trim();
+  if (!trimmed) return false;
+  return (
+    trimmed.startsWith("/") ||
+    trimmed.startsWith("./") ||
+    trimmed.startsWith("../") ||
+    trimmed.startsWith("~") ||
+    trimmed.startsWith("file://")
+  );
+}
+
+/** Markdown image ![alt](url) and link [label](url) – capture URL from both */
+const MARKDOWN_IMAGE_OR_LINK_RE = /!?\[[^\]]*\]\(([^)]+)\)/g;
+
+export type MarkdownSegment =
+  | { type: "text"; content: string }
+  | { type: "image"; content: string };
+
+/**
+ * Splits markdown into ordered segments. Local image URLs (including file://) are
+ * extracted so they can be sent as native image messages; surrounding text is kept in order.
+ * - If the whole input is a single line that looks like a local path, returns one image segment.
+ * - Otherwise finds ![alt](url) and [label](url); when url is local, produces text + image + text segments.
+ */
+export function parseMarkdownForLocalImages(text: string): MarkdownSegment[] {
+  const trimmed = text.trimEnd();
+  if (!trimmed) {
+    return [{ type: "text", content: text }];
+  }
+
+  // Single line that is a local path: treat entire content as one image
+  if (!trimmed.includes("\n")) {
+    if (isLocalPath(trimmed)) {
+      return [{ type: "image", content: trimmed }];
+    }
+    // Backtick-wrapped path e.g. `/tmp/foo.png` → treat as image
+    const backtickMatch = trimmed.match(/^`([^`]+)`$/);
+    if (backtickMatch && isLocalPath(backtickMatch[1].trim())) {
+      return [{ type: "image", content: backtickMatch[1].trim() }];
+    }
+    // Angle-bracket-wrapped path e.g. <file:///tmp/foo.png> → treat as image
+    const angleMatch = trimmed.match(/^<([^>]+)>$/);
+    if (angleMatch && isLocalPath(angleMatch[1].trim())) {
+      return [{ type: "image", content: angleMatch[1].trim() }];
+    }
+  }
+
+  const segments: MarkdownSegment[] = [];
+  let lastIndex = 0;
+  const re = new RegExp(MARKDOWN_IMAGE_OR_LINK_RE.source, "g");
+  let match: RegExpExecArray | null;
+  while ((match = re.exec(text)) !== null) {
+    const url = match[1].trim();
+    if (!isLocalPath(url)) continue;
+    if (match.index > lastIndex) {
+      segments.push({ type: "text", content: text.slice(lastIndex, match.index) });
+    }
+    segments.push({ type: "image", content: url });
+    lastIndex = re.lastIndex;
+  }
+
+  if (segments.length === 0) {
+    return [{ type: "text", content: text }];
+  }
+  if (lastIndex < text.length) {
+    segments.push({ type: "text", content: text.slice(lastIndex) });
+  }
+  return segments;
+}

package/src/media.ts

@@ -2,6 +2,8 @@
  * Infoflow native image sending: compress, base64-encode, and POST via Infoflow API.
  */
 
+import path from "node:path";
+import { fileURLToPath } from "node:url";
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import { resolveInfoflowAccount } from "./accounts.js";
 import { recordSentMessageId } from "./infoflow-req-parse.js";
@@ -90,8 +92,21 @@ export async function compressImageForInfoflow(params: {
 
 export type PrepareImageResult = { isImage: true; base64: string } | { isImage: false };
 
+function isLocalMediaUrl(url: string): boolean {
+  const t = url.trim();
+  return (
+    t.startsWith("file://") ||
+    t.startsWith("/") ||
+    t.startsWith("./") ||
+    t.startsWith("../") ||
+    t.startsWith("~")
+  );
+}
+
 /**
  * Downloads media, checks if it's an image, compresses to 1MB, and base64-encodes.
+ * For local paths, passes the file's parent directory as localRoots so any path is allowed
+ * (infoflow-only; does not change shared media layer).
  */
 export async function prepareInfoflowImageBase64(params: {
   mediaUrl: string;
@@ -100,11 +115,32 @@ export async function prepareInfoflowImageBase64(params: {
   const { mediaUrl, mediaLocalRoots } = params;
   const runtime = getInfoflowRuntime();
 
-  // Download media
+  let localRoots: readonly string[] | undefined;
+  if (isLocalMediaUrl(mediaUrl)) {
+    let absPath: string;
+    if (mediaUrl.trim().startsWith("file://")) {
+      try {
+        absPath = fileURLToPath(mediaUrl.trim());
+      } catch {
+        absPath = path.resolve(mediaUrl.replace(/^file:\/\//i, ""));
+      }
+    } else {
+      absPath = path.resolve(mediaUrl.trim());
+    }
+    const dir = path.dirname(absPath);
+    if (dir && dir !== path.parse(dir).root) {
+      localRoots = [dir];
+    } else {
+      localRoots = mediaLocalRoots?.length ? [...mediaLocalRoots] : undefined;
+    }
+  } else {
+    localRoots = mediaLocalRoots?.length ? [...mediaLocalRoots] : undefined;
+  }
+
   const loaded = await runtime.media.loadWebMedia(mediaUrl, {
     maxBytes: 30 * 1024 * 1024, // 30MB download limit
     optimizeImages: false,
-    localRoots: mediaLocalRoots?.length ? mediaLocalRoots : undefined,
+    localRoots: localRoots ?? undefined,
   });
 
   // Check if it's an image

package/src/reply-dispatcher.ts

@@ -4,6 +4,7 @@ import {
   type ReplyPayload,
 } from "openclaw/plugin-sdk";
 import { getInfoflowSendLog, formatInfoflowError, logVerbose } from "./logging.js";
+import { parseMarkdownForLocalImages } from "./markdown-local-images.js";
 import { prepareInfoflowImageBase64, sendInfoflowImageMessage } from "./media.js";
 import { getInfoflowRuntime } from "./runtime.js";
 import { sendInfoflowMessage } from "./send.js";
@@ -37,6 +38,8 @@ export type CreateInfoflowReplyDispatcherParams = {
   replyToMessageId?: string;
   /** Preview text of the inbound message for reply context */
   replyToPreview?: string;
+  /** Optional local filesystem roots for resolving local image paths in text */
+  mediaLocalRoots?: readonly string[];
 };
 
 /**
@@ -54,6 +57,7 @@ export function createInfoflowReplyDispatcher(params: CreateInfoflowReplyDispatc
     mentionIds,
     replyToMessageId,
     replyToPreview,
+    mediaLocalRoots,
   } = params;
   const core = getInfoflowRuntime();
 
@@ -150,81 +154,197 @@ export function createInfoflowReplyDispatcher(params: CreateInfoflowReplyDispatc
 
       // Chunk text to 2048 chars max (Infoflow limit)
       const chunks = core.channel.text.chunkText(messageText, 2048);
-      // Only include @mentions in the first chunk (avoid duplicate @s)
       let isFirstChunk = true;
+      const textPromises: Promise<{ ok?: boolean; error?: string }>[] = [];
 
       for (const chunk of chunks) {
-        const contents: InfoflowMessageContentItem[] = [];
-
-        // Add AT content nodes for group messages (first chunk only)
-        if (isFirstChunk && isGroup) {
-          if (hasAtAll) {
-            contents.push({ type: "at", content: "all" });
-          } else if (hasAtUsers) {
-            contents.push({ type: "at", content: allAtUserIds.join(",") });
+        const segments = parseMarkdownForLocalImages(chunk);
+
+        for (const segment of segments) {
+          const chunkReplyTo = !replyApplied ? replyTo : undefined;
+
+          if (segment.type === "text") {
+            const contents: InfoflowMessageContentItem[] = [];
+            if (isFirstChunk && isGroup) {
+              if (hasAtAll) {
+                contents.push({ type: "at", content: "all" });
+              } else if (hasAtUsers) {
+                contents.push({ type: "at", content: allAtUserIds.join(",") });
+              }
+              if (hasAtAgents) {
+                contents.push({ type: "at-agent", content: resolvedAgentIds.join(",") });
+              }
+            }
+            const trimmed = segment.content.trim();
+            if (contents.length > 0 || trimmed) {
+              contents.push({ type: "markdown", content: segment.content });
+              textPromises.push(
+                sendInfoflowMessage({
+                  cfg,
+                  to,
+                  contents,
+                  accountId,
+                  replyTo: chunkReplyTo,
+                }),
+              );
+              if (chunkReplyTo) replyApplied = true;
+            }
+            isFirstChunk = false;
+            continue;
+          }
+
+          // segment.type === "image"
+          if (isFirstChunk && isGroup && (hasAtAll || hasAtUsers || hasAtAgents)) {
+            const atContents: InfoflowMessageContentItem[] = [];
+            if (hasAtAll) atContents.push({ type: "at", content: "all" });
+            else if (hasAtUsers) atContents.push({ type: "at", content: allAtUserIds.join(",") });
+            if (hasAtAgents)
+              atContents.push({ type: "at-agent", content: resolvedAgentIds.join(",") });
+            atContents.push({ type: "markdown", content: "" });
+            textPromises.push(
+              sendInfoflowMessage({
+                cfg,
+                to,
+                contents: atContents,
+                accountId,
+                replyTo: chunkReplyTo,
+              }),
+            );
+            if (chunkReplyTo) replyApplied = true;
           }
-          if (hasAtAgents) {
-            contents.push({ type: "at-agent", content: resolvedAgentIds.join(",") });
+          isFirstChunk = false;
+
+          try {
+            const prepared = await prepareInfoflowImageBase64({
+              mediaUrl: segment.content,
+              mediaLocalRoots: mediaLocalRoots ?? undefined,
+            });
+            if (prepared.isImage) {
+              const segmentReplyTo = !replyApplied ? replyTo : undefined;
+              textPromises.push(
+                sendInfoflowImageMessage({
+                  cfg,
+                  to,
+                  base64Image: prepared.base64,
+                  accountId,
+                  replyTo: segmentReplyTo,
+                }).then((r) => {
+                  if (r.ok) return r;
+                  logVerbose(
+                    `[infoflow] native image send failed: ${r.error}, falling back to link`,
+                  );
+                  return sendInfoflowMessage({
+                    cfg,
+                    to,
+                    contents: [{ type: "link", content: segment.content }],
+                    accountId,
+                    replyTo: segmentReplyTo,
+                  });
+                }),
+              );
+              if (!replyApplied) replyApplied = true;
+            } else {
+              textPromises.push(
+                sendInfoflowMessage({
+                  cfg,
+                  to,
+                  contents: [{ type: "link", content: segment.content }],
+                  accountId,
+                  replyTo: !replyApplied ? replyTo : undefined,
+                }),
+              );
+              if (!replyApplied) replyApplied = true;
+            }
+          } catch (err) {
+            logVerbose(
+              `[infoflow] image prep failed in text segment, falling back to link: ${err}`,
+            );
+            textPromises.push(
+              sendInfoflowMessage({
+                cfg,
+                to,
+                contents: [{ type: "link", content: segment.content }],
+                accountId,
+                replyTo: !replyApplied ? replyTo : undefined,
+              }),
+            );
+            if (!replyApplied) replyApplied = true;
           }
         }
-        isFirstChunk = false;
-
-        // Add markdown content
-        contents.push({ type: "markdown", content: chunk });
-
-        // Only include replyTo on the first outbound message
-        const chunkReplyTo = !replyApplied ? replyTo : undefined;
-        const result = await sendInfoflowMessage({
-          cfg,
-          to,
-          contents,
-          accountId,
-          replyTo: chunkReplyTo,
-        });
-        if (chunkReplyTo) replyApplied = true;
-
-        if (result.ok) {
-          statusSink?.({ lastOutboundAt: Date.now() });
-        } else if (result.error) {
-          getInfoflowSendLog().error(
-            `[infoflow] reply failed to=${to}, accountId=${accountId}: ${result.error}`,
-          );
+      }
+
+      if (textPromises.length > 0) {
+        const results = await Promise.all(textPromises);
+        for (const result of results) {
+          if (result?.ok) {
+            statusSink?.({ lastOutboundAt: Date.now() });
+          } else if (result?.error) {
+            getInfoflowSendLog().error(
+              `[infoflow] reply failed to=${to}, accountId=${accountId}: ${result.error}`,
+            );
+          }
         }
       }
     }
 
-    // --- Media handling: send each media item as native image or fallback link ---
+    // --- Media handling: send each media item as native image or fallback link (b-mode: collect then await) ---
+    const mediaPromises: Promise<{ ok?: boolean; error?: string }>[] = [];
     for (const mediaUrl of mediaList) {
       const mediaReplyTo = !replyApplied ? replyTo : undefined;
       try {
         const prepared = await prepareInfoflowImageBase64({ mediaUrl });
         if (prepared.isImage) {
-          const result = await sendInfoflowImageMessage({
+          mediaPromises.push(
+            sendInfoflowImageMessage({
+              cfg,
+              to,
+              base64Image: prepared.base64,
+              accountId,
+              replyTo: mediaReplyTo,
+            }).then((r) => {
+              if (r.ok) return r;
+              logVerbose(`[infoflow] native image send failed: ${r.error}, falling back to link`);
+              return sendInfoflowMessage({
+                cfg,
+                to,
+                contents: [{ type: "link", content: mediaUrl }],
+                accountId,
+                replyTo: mediaReplyTo,
+              });
+            }),
+          );
+          if (mediaReplyTo) replyApplied = true;
+        } else {
+          mediaPromises.push(
+            sendInfoflowMessage({
+              cfg,
+              to,
+              contents: [{ type: "link", content: mediaUrl }],
+              accountId,
+              replyTo: mediaReplyTo,
+            }),
+          );
+          if (mediaReplyTo) replyApplied = true;
+        }
+      } catch (err) {
+        logVerbose(`[infoflow] image prep failed, falling back to link: ${err}`);
+        mediaPromises.push(
+          sendInfoflowMessage({
             cfg,
             to,
-            base64Image: prepared.base64,
+            contents: [{ type: "link", content: mediaUrl }],
             accountId,
             replyTo: mediaReplyTo,
-          });
-          if (result.ok) {
-            if (mediaReplyTo) replyApplied = true;
-            statusSink?.({ lastOutboundAt: Date.now() });
-            continue;
-          }
-          logVerbose(`[infoflow] native image send failed: ${result.error}, falling back to link`);
-        }
-      } catch (err) {
-        logVerbose(`[infoflow] image prep failed, falling back to link: ${err}`);
+          }),
+        );
+        if (mediaReplyTo) replyApplied = true;
+      }
+    }
+    if (mediaPromises.length > 0) {
+      const results = await Promise.all(mediaPromises);
+      for (const result of results) {
+        if (result?.ok) statusSink?.({ lastOutboundAt: Date.now() });
       }
-      // Fallback: send as link
-      await sendInfoflowMessage({
-        cfg,
-        to,
-        contents: [{ type: "link", content: mediaUrl }],
-        accountId,
-        replyTo: mediaReplyTo,
-      });
-      if (mediaReplyTo) replyApplied = true;
     }
   };
 

package/src/types.ts

@@ -22,7 +22,7 @@ export type InfoflowReplyMode =
 export type InfoflowGroupConfig = {
   replyMode?: InfoflowReplyMode;
   watchMentions?: string[];
-  watchRegex?: string;
+  watchRegex?: string[];
   followUp?: boolean;
   followUpWindow?: number;
   systemPrompt?: string;
@@ -45,6 +45,8 @@ export type InfoflowInboundBodyItem = {
   userid?: string;
   /** IMAGE 类型 body item 的图片下载地址 */
   downloadurl?: string;
+  /** replyData 类型 body item 中被引用消息的 ID */
+  messageid?: string | number;
 };
 
 /** Mention IDs extracted from inbound group AT items (excluding the bot itself) */
@@ -114,7 +116,7 @@ export type InfoflowAccountConfig = {
    *  the bot analyzes the message and replies only if confident. */
   watchMentions?: string[];
   /** Regex pattern to watch for in message content; triggers bot activation when matched */
-  watchRegex?: string;
+  watchRegex?: string[];
   /** Reply mode controlling bot engagement level in groups */
   replyMode?: InfoflowReplyMode;
   /** Enable follow-up replies after bot responds to a mention (default: true) */
@@ -153,7 +155,7 @@ export type ResolvedInfoflowAccount = {
      *  the bot analyzes the message and replies only if confident. */
     watchMentions?: string[];
     /** Regex pattern to watch for in message content; triggers bot activation when matched */
-    watchRegex?: string;
+    watchRegex?: string[];
     /** Reply mode controlling bot engagement level in groups */
     replyMode?: InfoflowReplyMode;
     /** Enable follow-up replies after bot responds to a mention (default: true) */
@@ -191,6 +193,8 @@ export type InfoflowMessageEvent = {
   mentionIds?: InfoflowMentionIds;
   /** Reply/quote context extracted from replyData body items (supports multiple quotes) */
   replyContext?: string[];
+  /** Whether the message is a reply (引用回复) to one of the bot's own messages */
+  isReplyToBot?: boolean;
   /** Image download URLs extracted from IMAGE body items (group) or PicUrl (private) */
   imageUrls?: string[];
 };