@core-workspace/infoflow-openclaw-plugin 2026.3.9 → 2026.3.27-beta.0

package/src/logging.ts

@@ -3,7 +3,7 @@
  * Provides consistent logging interface across all Infoflow modules.
  */
 
-import type { RuntimeLogger } from "openclaw/plugin-sdk";
+import type { RuntimeLogger } from "openclaw/plugin-sdk/plugin-runtime";
 import { getInfoflowRuntime } from "./runtime.js";
 
 // ---------------------------------------------------------------------------

package/src/runtime.ts

@@ -1,4 +1,4 @@
-import type { PluginRuntime } from "openclaw/plugin-sdk";
+import type { PluginRuntime } from "openclaw/plugin-sdk/core";
 
 let runtime: PluginRuntime | null = null;
 

package/src/security/dm-policy.ts

@@ -21,10 +21,7 @@ export type DmPolicyResult =
  * - "pairing": allowed (pairing handled by the framework), note returned
  * - "allowlist": only senders in allowFrom are allowed
  */
-export function checkDmPolicy(
-  account: ResolvedInfoflowAccount,
-  fromuser: string,
-): DmPolicyResult {
+export function checkDmPolicy(account: ResolvedInfoflowAccount, fromuser: string): DmPolicyResult {
   const dmPolicy = account.config.dmPolicy ?? "open";
 
   if (dmPolicy === "allowlist") {

package/src/security/group-policy.ts

@@ -4,56 +4,62 @@
  * follow-up window tracking, and conditional-reply prompt builders.
  */
 
+import { getInfoflowBotLog } from "../logging.js";
 import type {
+  InfoflowInboundBodyItem,
   InfoflowReplyMode,
   InfoflowGroupConfig,
+  InfoflowGroupSessionMode,
   InfoflowMentionIds,
   ResolvedInfoflowAccount,
 } from "../types.js";
-
-// ---------------------------------------------------------------------------
-// Body item type (inbound group messages)
-// ---------------------------------------------------------------------------
-
-export type InfoflowBodyItem = {
-  type?: string;
-  content?: string;
-  label?: string;
-  /** 机器人 AT 时有此字段（数字），与 userid 互斥 */
-  robotid?: number;
-  /** AT 元素的显示名称 */
-  name?: string;
-  /** 人类用户 AT 时有此字段（uuap name），与 robotid 互斥 */
-  userid?: string;
-  /** IMAGE 类型 body item 的图片下载地址 */
-  downloadurl?: string;
-};
+import { findSentMessage } from "../utils/store/message-store.js";
 
 // ---------------------------------------------------------------------------
 // @mention detection
 // ---------------------------------------------------------------------------
 
 /**
- * Check if the bot was @mentioned in the message body.
- * Matches by robotName against the AT item's display name (case-insensitive).
+ * Check if the current bot was @mentioned in the message body.
+ *
+ * Priority order per AT item (only checks fields present in both config and item):
+ * 1. appAgentId vs item.robotid (string comparison)
+ * 2. robotName vs item.name (display name, case-insensitive)
+ * 3. robotId vs item.robotid (string comparison)
+ *
+ * All robotid comparisons use string form to avoid precision loss on large IDs.
  */
-export function checkBotMentioned(bodyItems: InfoflowBodyItem[], robotName?: string): boolean {
-  if (!robotName) return false;
-  const normalizedRobotName = robotName.toLowerCase();
+export function checkBotMentioned(
+  bodyItems: InfoflowInboundBodyItem[],
+  botIdentity: { robotName?: string; appAgentId?: number; robotId?: string },
+): boolean {
+  const { robotName, appAgentId, robotId } = botIdentity;
+  const appAgentIdStr = appAgentId != null ? String(appAgentId) : undefined;
   for (const item of bodyItems) {
     if (item.type !== "AT") continue;
-    if (item.name?.toLowerCase() === normalizedRobotName) return true;
+    // 1. appAgentId vs item.robotid
+    if (appAgentIdStr && item.robotid != null && String(item.robotid) === appAgentIdStr)
+      return true;
+    // 2. robotName vs item.name (display name, case-insensitive)
+    if (robotName && item.name && item.name.toLowerCase() === robotName.toLowerCase()) return true;
+    // 3. robotId vs item.robotid
+    if (robotId && item.robotid != null && String(item.robotid) === robotId) return true;
   }
   return false;
 }
 
+/** Returns true if the message body contains an AT item for any bot. */
+export function hasAnyRobotMention(bodyItems: InfoflowInboundBodyItem[]): boolean {
+  return bodyItems.some((item) => item.type === "AT" && item.robotid != null);
+}
+
 /**
  * Check if any entry in the watchlist was @mentioned in the message body.
  * Matching priority: userid > robotid (parsed as number) > name (fallback).
  * Returns the matched ID (from watchMentions), or undefined if none matched.
  */
 export function checkWatchMentioned(
-  bodyItems: InfoflowBodyItem[],
+  bodyItems: InfoflowInboundBodyItem[],
   watchMentions: string[],
 ): string | undefined {
   if (!watchMentions.length) return undefined;
@@ -82,13 +88,34 @@ export function checkWatchMentioned(
   return undefined;
 }
 
-/** Check if message content matches the configured watchRegex regex pattern */
-export function checkWatchRegex(mes: string, pattern: string): boolean {
+// Cache compiled regexes to avoid recompilation on every message
+const regexCache = new Map<string, RegExp | null>();
+const MAX_REGEX_CACHE = 256;
+
+function getCachedRegex(pattern: string): RegExp | null {
+  let re = regexCache.get(pattern);
+  if (re !== undefined) return re;
   try {
-    return new RegExp(pattern, "i").test(mes);
-  } catch {
-    return false;
+    re = new RegExp(pattern, "is");
+  } catch (err) {
+    getInfoflowBotLog().warn(
+      `Invalid watchRegex pattern "${pattern}", skipping: ${err instanceof Error ? err.message : String(err)}`,
+    );
+    re = null;
+  }
+  if (regexCache.size >= MAX_REGEX_CACHE) regexCache.clear();
+  regexCache.set(pattern, re);
+  return re;
+}
+
+/** Check if message content matches any configured watchRegex pattern. Returns matched pattern or undefined. */
+export function checkWatchRegex(mes: string, patterns: string | string[]): string | undefined {
+  const list = Array.isArray(patterns) ? patterns : [patterns];
+  for (const pattern of list) {
+    const re = getCachedRegex(pattern);
+    if (re?.test(mes)) return pattern;
   }
+  return undefined;
 }
 
 /**
@@ -96,10 +123,12 @@ export function checkWatchRegex(mes: string, pattern: string): boolean {
  * Returns human userIds and robot agentIds (excluding the bot itself).
  */
 export function extractMentionIds(
-  bodyItems: InfoflowBodyItem[],
+  bodyItems: InfoflowInboundBodyItem[],
   robotName?: string,
+  robotId?: string,
 ): InfoflowMentionIds {
   const normalizedRobotName = robotName?.toLowerCase();
+  const normalizedRobotId = robotId?.trim();
   const userIds: string[] = [];
   const agentIds: number[] = [];
   const seenUsers = new Set<string>();
@@ -109,6 +138,7 @@ export function extractMentionIds(
     if (item.type !== "AT") continue;
 
     if (item.robotid != null) {
+      if (normalizedRobotId && String(item.robotid) === normalizedRobotId) continue;
       if (normalizedRobotName && item.name?.toLowerCase() === normalizedRobotName) continue;
       if (!seenAgents.has(item.robotid)) {
         seenAgents.add(item.robotid);
@@ -125,6 +155,60 @@ export function extractMentionIds(
   return { userIds, agentIds };
 }
 
+/**
+ * Extract the bot's own robotid from AT items in the message body.
+ * When the bot is @mentioned, the AT item contains the bot's actual numeric robotid.
+ * Returns the robotid string if found, undefined otherwise.
+ */
+export function getBotRobotidFromBody(
+  bodyItems: InfoflowInboundBodyItem[],
+  robotName?: string,
+  robotId?: string,
+): string | undefined {
+  const normalizedRobotName = robotName?.toLowerCase();
+  const normalizedRobotId = robotId?.trim();
+  for (const item of bodyItems) {
+    if (item.type !== "AT") continue;
+    if (normalizedRobotId && item.robotid != null && String(item.robotid) === normalizedRobotId) {
+      return normalizedRobotId;
+    }
+    if (
+      normalizedRobotName &&
+      item.name?.toLowerCase() === normalizedRobotName &&
+      item.robotid != null
+    ) {
+      return String(item.robotid);
+    }
+  }
+  return undefined;
+}
+
+/**
+ * Check if a message is a quoted reply to one of the bot's own previously sent messages.
+ * Looks up replyData body items' messageid in the sent-message store.
+ */
+export function checkReplyToBot(bodyItems: InfoflowInboundBodyItem[], accountId: string): boolean {
+  for (const item of bodyItems) {
+    if (item.type !== "replyData") continue;
+    const msgId = item.messageid;
+    if (msgId == null) continue;
+    try {
+      if (findSentMessage(accountId, msgId)) return true;
+    } catch {
+      // DB error — gracefully continue
+    }
+  }
+  return false;
+}
+
+/**
+ * Check if the mention IDs contain any non-bot mentions (other users or other robots).
+ */
+export function hasOtherMentions(mentionIds?: InfoflowMentionIds): boolean {
+  if (!mentionIds) return false;
+  return mentionIds.userIds.length > 0 || mentionIds.agentIds.length > 0;
+}
+
 // ---------------------------------------------------------------------------
 // Follow-up window tracking (in-memory)
 // ---------------------------------------------------------------------------
@@ -150,10 +234,11 @@ export function isWithinFollowUpWindow(groupId: string, windowSeconds: number):
 
 export type ResolvedGroupConfig = {
   replyMode: InfoflowReplyMode;
+  groupSessionMode: InfoflowGroupSessionMode;
   followUp: boolean;
   followUpWindow: number;
   watchMentions: string[];
-  watchRegex?: string;
+  watchRegex?: string | string[];
   systemPrompt?: string;
 };
 
@@ -175,6 +260,7 @@ export function resolveGroupConfig(
     groupId != null ? account.config.groups?.[String(groupId)] : undefined;
   return {
     replyMode: groupCfg?.replyMode ?? account.config.replyMode ?? inferLegacyReplyMode(account),
+    groupSessionMode: groupCfg?.groupSessionMode ?? account.config.groupSessionMode ?? "group",
     followUp: groupCfg?.followUp ?? account.config.followUp ?? true,
     followUpWindow: groupCfg?.followUpWindow ?? account.config.followUpWindow ?? 300,
     watchMentions: groupCfg?.watchMentions ?? account.config.watchMentions ?? [],
@@ -189,26 +275,32 @@ export function resolveGroupConfig(
 
 function buildReplyJudgmentRules(): string {
   return [
-    "# Rules",
+    "# Rules for Group Message Response",
+    "",
+    "## When to Reply",
     "",
-    "## Can answer or help → Reply directly",
+    "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",
     "",
-    "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",
+    "## When NOT to Reply — output only `NO_REPLY`",
     "",
-    "## Cannot answer → Reply with NO_REPLY only",
+    "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",
     "",
-    "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",
+    "## Response Format",
     "",
-    "# Response format",
+    "- 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.",
     "",
-    "- 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.",
+    "## 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");
 }
 
@@ -249,15 +341,46 @@ export function buildWatchRegexPrompt(pattern: string): string {
 }
 
 /** GroupSystemPrompt for follow-up replies after bot's last response */
-export function buildFollowUpPrompt(): string {
-  return [
+export 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.",
+    "",
+  ];
+
+  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",
     "",
-    "Note: If this message is clearly a new topic or unrelated to your previous reply, respond with NO_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(),
-  ].join("\n");
+  );
+
+  return lines.join("\n");
 }
 
 /** GroupSystemPrompt for proactive mode */

package/src/tools/actions/index.ts

@@ -4,10 +4,10 @@
  * @all and @user mentions in group messages.
  */
 
-import type { ChannelMessageActionAdapter, ChannelMessageActionName } from "openclaw/plugin-sdk";
-import { extractToolSend, jsonResult, readStringParam } from "openclaw/plugin-sdk";
+import type { ChannelMessageActionAdapter } from "openclaw/plugin-sdk/channel-contract";
+import { extractToolSend, jsonResult, readStringParam } from "../../compat/openclaw-sdk.js";
+import { normalizeInfoflowTarget } from "../../adapter/outbound/target-resolver.js";
 import { resolveInfoflowAccount } from "../../channel/accounts.js";
-import { logVerbose } from "../../logging.js";
 import { prepareInfoflowImageBase64, sendInfoflowImageMessage } from "../../channel/media.js";
 import {
   sendInfoflowMessage,
@@ -15,13 +15,13 @@ import {
   recallInfoflowPrivateMessage,
   isLikelyLocalPath,
 } from "../../channel/outbound.js";
+import { logVerbose } from "../../logging.js";
+import type { InfoflowMessageContentItem, InfoflowOutboundReply } from "../../types.js";
 import {
   findSentMessage,
   querySentMessages,
   removeRecalledMessages,
 } from "../../utils/store/message-store.js";
-import { normalizeInfoflowTarget } from "../../adapter/outbound/target-resolver.js";
-import type { InfoflowMessageContentItem, InfoflowOutboundReply } from "../../types.js";
 
 // Recall result hint constants — reused across single/batch, group/private recall paths
 const RECALL_OK_HINT = "Recall succeeded. output only NO_REPLY with no other text.";
@@ -30,12 +30,12 @@ const RECALL_PARTIAL_HINT =
   "Some recalls failed. Send a brief reply stating only the failure reason(s).";
 
 export const infoflowMessageActions: ChannelMessageActionAdapter = {
-  listActions: (): ChannelMessageActionName[] => ["send", "delete"],
+  describeMessageTool: () => ({ actions: ["send", "delete"] }),
 
   extractToolSend: ({ args }) => extractToolSend(args, "sendMessage"),
-  
+
   handleAction: async ({ action, params, cfg, accountId }) => {
-      // -----------------------------------------------------------------------
+    // -----------------------------------------------------------------------
     // delete (群消息撤回) — Mode A: by messageId, Mode B: by count
     // -----------------------------------------------------------------------
     if (action === "delete") {
@@ -313,7 +313,9 @@ export const infoflowMessageActions: ChannelMessageActionAdapter = {
     const mediaUrl = readStringParam(params, "media", { trim: false });
 
     // Log sendMessage action call
-    logVerbose(`[DEBUG actions:send] action=send, to=${to}, message="${message}", mediaUrl="${mediaUrl}"`);
+    logVerbose(
+      `[DEBUG actions:send] action=send, to=${to}, message="${message}", mediaUrl="${mediaUrl}"`,
+    );
 
     // Infoflow-specific mention params
     const atAll = params.atAll === true || params.atAll === "true";
@@ -322,12 +324,12 @@ export const infoflowMessageActions: ChannelMessageActionAdapter = {
     const isGroup = /^group:\d+$/i.test(to);
     const contents: InfoflowMessageContentItem[] = [];
 
-    // Infoflow reply-to params (group only)
+    // Infoflow reply-to params
     const replyToMessageId = readStringParam(params, "replyToMessageId");
     const replyToPreview = readStringParam(params, "replyToPreview");
     const replyTypeRaw = readStringParam(params, "replyType");
     const replyTo: InfoflowOutboundReply | undefined =
-      replyToMessageId && isGroup
+      replyToMessageId
         ? {
             messageid: replyToMessageId,
             preview: replyToPreview ?? undefined,
@@ -389,8 +391,8 @@ export const infoflowMessageActions: ChannelMessageActionAdapter = {
 
       // Try native image send, fallback to link
       try {
-        const paths = isLikelyLocalPath(mediaUrl)?[mediaUrl]:undefined;
-        const prepared = await prepareInfoflowImageBase64({ mediaUrl, mediaLocalRoots:paths });
+        const paths = isLikelyLocalPath(mediaUrl) ? [mediaUrl] : undefined;
+        const prepared = await prepareInfoflowImageBase64({ mediaUrl, mediaLocalRoots: paths });
         logVerbose(`prepareInfoflowImageBase64 result: isImage=${prepared.isImage}`);
         if (prepared.isImage) {
           const imgResult = await sendInfoflowImageMessage({