@chbo297/infoflow 2026.2.27 → 2026.3.2

package/src/infoflow-req-parse.ts

@@ -7,7 +7,7 @@ import { createDedupeCache } from "openclaw/plugin-sdk";
 // ---------------------------------------------------------------------------
 import { handlePrivateChatMessage, handleGroupChatMessage } from "./bot.js";
 import type { ResolvedInfoflowAccount } from "./channel.js";
-import { getInfoflowParseLog } from "./logging.js";
+import { getInfoflowParseLog, formatInfoflowError, logVerbose } from "./logging.js";
 
 const DEDUP_TTL_MS = 5 * 60 * 1000; // 5 minutes
 const DEDUP_MAX_SIZE = 1000;
@@ -138,9 +138,7 @@ function parseXmlMessage(xmlString: string): Record<string, string> | null {
 // Types
 // ---------------------------------------------------------------------------
 
-type InfoflowCoreRuntime = {
-  logging: { shouldLogVerbose(): boolean };
-};
+type InfoflowCoreRuntime = Record<string, unknown>;
 
 export type WebhookTarget = {
   account: ResolvedInfoflowAccount;
@@ -216,14 +214,9 @@ export async function parseAndDispatchInfoflowRequest(
   rawBody: string,
   targets: WebhookTarget[],
 ): Promise<ParseResult> {
-  const verbose = targets[0]?.core?.logging?.shouldLogVerbose?.() ?? false;
   const contentType = String(req.headers["content-type"] ?? "").toLowerCase();
 
-  if (verbose) {
-    getInfoflowParseLog().debug?.(
-      `[infoflow] parseAndDispatch: contentType=${contentType}, bodyLen=${rawBody.length}`,
-    );
-  }
+  logVerbose(`[infoflow] parseAndDispatch: contentType=${contentType}, bodyLen=${rawBody.length}`);
 
   // --- form-urlencoded: echostr verification + private chat ---
   if (contentType.startsWith("application/x-www-form-urlencoded")) {
@@ -248,14 +241,16 @@ export async function parseAndDispatchInfoflowRequest(
           return { handled: true, statusCode: 200, body: echostr };
         }
       }
-      getInfoflowParseLog().error(`[infoflow] echostr signature mismatch`);
+      getInfoflowParseLog().error(
+        `[infoflow] echostr signature mismatch (tried ${targets.length} account(s))`,
+      );
       return { handled: true, statusCode: 403, body: "Invalid signature" };
     }
 
     // private chat message (messageJson field in form)
     const messageJsonStr = form.get("messageJson") ?? "";
     if (messageJsonStr) {
-      return handlePrivateMessage(messageJsonStr, targets, verbose);
+      return handlePrivateMessage(messageJsonStr, targets);
     }
 
     getInfoflowParseLog().error(`[infoflow] form-urlencoded but missing echostr or messageJson`);
@@ -264,7 +259,7 @@ export async function parseAndDispatchInfoflowRequest(
 
   // --- text/plain: group chat ---
   if (contentType.startsWith("text/plain")) {
-    return handleGroupMessage(rawBody, targets, verbose);
+    return handleGroupMessage(rawBody, targets);
   }
 
   // --- unsupported Content-Type ---
@@ -280,7 +275,6 @@ type DecryptDispatchParams = {
   encryptedContent: string;
   targets: WebhookTarget[];
   chatType: "direct" | "group";
-  verbose: boolean;
   fallbackParser?: (content: string) => Record<string, unknown> | null;
   /** Async handler to process the decrypted message. Errors are caught internally. */
   dispatchFn: (target: WebhookTarget, msgData: Record<string, unknown>) => Promise<void>;
@@ -292,7 +286,7 @@ type DecryptDispatchParams = {
  * Dispatches asynchronously (fire-and-forget) with centralized error logging.
  */
 function tryDecryptAndDispatch(params: DecryptDispatchParams): ParseResult {
-  const { encryptedContent, targets, chatType, verbose, fallbackParser, dispatchFn } = params;
+  const { encryptedContent, targets, chatType, fallbackParser, dispatchFn } = params;
 
   if (targets.length === 0) {
     getInfoflowParseLog().error(`[infoflow] ${chatType}: no target configured`);
@@ -327,9 +321,7 @@ function tryDecryptAndDispatch(params: DecryptDispatchParams): ParseResult {
 
     if (msgData && Object.keys(msgData).length > 0) {
       if (isDuplicateMessage(msgData)) {
-        if (verbose) {
-          getInfoflowParseLog().debug?.(`[infoflow] ${chatType}: duplicate message, skipping`);
-        }
+        logVerbose(`[infoflow] ${chatType}: duplicate message, skipping`);
         return { handled: true, statusCode: 200, body: "success" };
       }
 
@@ -338,18 +330,18 @@ function tryDecryptAndDispatch(params: DecryptDispatchParams): ParseResult {
       // Fire-and-forget with centralized error handling
       void dispatchFn(target, msgData).catch((err) => {
         getInfoflowParseLog().error(
-          `[infoflow] ${chatType} handler error: ${err instanceof Error ? err.message : String(err)}`,
+          `[infoflow] ${chatType} handler error: ${formatInfoflowError(err)}`,
         );
       });
 
-      if (verbose) {
-        getInfoflowParseLog().debug?.(`[infoflow] ${chatType}: message dispatched successfully`);
-      }
+      logVerbose(`[infoflow] ${chatType}: message dispatched successfully`);
       return { handled: true, statusCode: 200, body: "success" };
     }
   }
 
-  getInfoflowParseLog().error(`[infoflow] ${chatType}: decryption failed for all accounts`);
+  getInfoflowParseLog().error(
+    `[infoflow] ${chatType}: decryption failed for all ${targets.length} account(s)`,
+  );
   return { handled: true, statusCode: 500, body: "decryption failed for all accounts" };
 }
 
@@ -362,11 +354,7 @@ function tryDecryptAndDispatch(params: DecryptDispatchParams): ParseResult {
  * Decrypts the Encrypt field with encodingAESKey (AES-ECB),
  * parses the decrypted content, then dispatches to bot.ts.
  */
-function handlePrivateMessage(
-  messageJsonStr: string,
-  targets: WebhookTarget[],
-  verbose: boolean,
-): ParseResult {
+function handlePrivateMessage(messageJsonStr: string, targets: WebhookTarget[]): ParseResult {
   let messageJson: Record<string, unknown>;
   try {
     messageJson = JSON.parse(messageJsonStr) as Record<string, unknown>;
@@ -385,7 +373,6 @@ function handlePrivateMessage(
     encryptedContent: encrypt,
     targets,
     chatType: "direct",
-    verbose,
     fallbackParser: parseXmlMessage,
     dispatchFn: (target, msgData) =>
       handlePrivateChatMessage({
@@ -406,16 +393,11 @@ function handlePrivateMessage(
  * The rawBody itself is an AES-encrypted ciphertext (Base64URLSafe encoded).
  * Decrypts and dispatches to bot.ts.
  */
-function handleGroupMessage(
-  rawBody: string,
-  targets: WebhookTarget[],
-  verbose: boolean,
-): ParseResult {
+function handleGroupMessage(rawBody: string, targets: WebhookTarget[]): ParseResult {
   return tryDecryptAndDispatch({
     encryptedContent: rawBody,
     targets,
     chatType: "group",
-    verbose,
     dispatchFn: (target, msgData) =>
       handleGroupChatMessage({
         cfg: target.config,

package/src/logging.ts

@@ -96,36 +96,18 @@ export function formatInfoflowError(err: unknown, options?: FormatErrorOptions):
   return String(err);
 }
 
-export type LogApiErrorOptions = {
-  /** Logger to use (defaults to send logger) */
-  logger?: RuntimeLogger;
-  /** Include stack trace in the log (default: false) */
-  includeStack?: boolean;
-};
-
 /**
- * Log an API error with operation context and structured metadata.
- * @param operation - The API operation name (e.g., "sendPrivate", "getToken")
- * @param error - The error to log
- * @param options - Logging options
+ * Log a message when verbose mode is enabled.
+ * Checks shouldLogVerbose() via PluginRuntime, then writes to console for
+ * --verbose terminal output. Safe to call before runtime is initialized.
  */
-export function logInfoflowApiError(
-  operation: string,
-  error: unknown,
-  options?: LogApiErrorOptions | RuntimeLogger,
-): void {
-  // Support legacy signature: logInfoflowApiError(op, err, logger)
-  const opts: LogApiErrorOptions =
-    options && "error" in options ? { logger: options as RuntimeLogger } : (options ?? {});
-
-  const log = opts.logger ?? getInfoflowSendLog();
-  const errMsg = formatInfoflowError(error, { includeStack: opts.includeStack });
-
-  // Use structured meta for better log aggregation and filtering
-  log.error(`[infoflow:${operation}] ${errMsg}`, {
-    operation,
-    errorType: error instanceof Error ? error.constructor.name : typeof error,
-  });
+export function logVerbose(message: string): void {
+  try {
+    if (!getInfoflowRuntime().logging.shouldLogVerbose()) return;
+    console.log(message);
+  } catch {
+    // runtime not available, skip verbose logging
+  }
 }
 
 // ---------------------------------------------------------------------------

package/src/monitor.ts

@@ -6,7 +6,7 @@ import {
   loadRawBody,
   type WebhookTarget,
 } from "./infoflow-req-parse.js";
-import { getInfoflowWebhookLog } from "./logging.js";
+import { getInfoflowWebhookLog, formatInfoflowError, logVerbose } from "./logging.js";
 import { getInfoflowRuntime } from "./runtime.js";
 
 // ---------------------------------------------------------------------------
@@ -88,16 +88,11 @@ export async function handleInfoflowWebhookRequest(
   req: IncomingMessage,
   res: ServerResponse,
 ): Promise<boolean> {
-  const core = getInfoflowRuntime();
-  const verbose = core.logging.shouldLogVerbose();
-
   const url = new URL(req.url ?? "/", "http://localhost");
   const requestPath = normalizeWebhookPath(url.pathname);
 
-  if (verbose) {
-    // Log the full request URL
-    getInfoflowWebhookLog().debug?.(`[infoflow] request: url=${url}`);
-  }
+  // Log the full request URL
+  logVerbose(`[infoflow] request: url=${url}`);
 
   // Check if path matches Infoflow webhook pattern
   if (!isInfoflowPath(requestPath)) {
@@ -130,18 +125,15 @@ export async function handleInfoflowWebhookRequest(
   try {
     result = await parseAndDispatchInfoflowRequest(req, bodyResult.raw, targets);
   } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
-    getInfoflowWebhookLog().error(`[infoflow] webhook handler error: ${errMsg}`);
+    getInfoflowWebhookLog().error(`[infoflow] webhook handler error: ${formatInfoflowError(err)}`);
     res.statusCode = 500;
     res.end("internal error");
     return true;
   }
 
-  if (verbose) {
-    getInfoflowWebhookLog().debug?.(
-      `[infoflow] dispatch result: handled=${result.handled}, status=${result.handled ? result.statusCode : "N/A"}`,
-    );
-  }
+  logVerbose(
+    `[infoflow] dispatch result: handled=${result.handled}, status=${result.handled ? result.statusCode : "N/A"}`,
+  );
 
   if (result.handled) {
     const looksLikeJson = result.body.startsWith("{");

package/src/reply-dispatcher.ts

@@ -3,10 +3,10 @@ import {
   type OpenClawConfig,
   type ReplyPayload,
 } from "openclaw/plugin-sdk";
-import { getInfoflowSendLog } from "./logging.js";
+import { getInfoflowSendLog, formatInfoflowError, logVerbose } from "./logging.js";
 import { getInfoflowRuntime } from "./runtime.js";
 import { sendInfoflowMessage } from "./send.js";
-import type { InfoflowAtOptions, InfoflowMessageContentItem } from "./types.js";
+import type { InfoflowAtOptions, InfoflowMentionIds, InfoflowMessageContentItem } from "./types.js";
 
 export type CreateInfoflowReplyDispatcherParams = {
   cfg: OpenClawConfig;
@@ -17,6 +17,8 @@ export type CreateInfoflowReplyDispatcherParams = {
   statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
   /** AT options for @mentioning members in group messages */
   atOptions?: InfoflowAtOptions;
+  /** Mention IDs from inbound message for resolving @id in LLM output */
+  mentionIds?: InfoflowMentionIds;
 };
 
 /**
@@ -24,7 +26,7 @@ export type CreateInfoflowReplyDispatcherParams = {
  * Encapsulates prefix options, chunked deliver (send via Infoflow API + statusSink), and onError.
  */
 export function createInfoflowReplyDispatcher(params: CreateInfoflowReplyDispatcherParams) {
-  const { cfg, agentId, accountId, to, statusSink, atOptions } = params;
+  const { cfg, agentId, accountId, to, statusSink, atOptions, mentionIds } = params;
   const core = getInfoflowRuntime();
 
   const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
@@ -37,42 +39,109 @@ export function createInfoflowReplyDispatcher(params: CreateInfoflowReplyDispatc
   // Check if target is a group (format: group:<id>)
   const isGroup = /^group:\d+$/i.test(to);
 
+  // Build id→type map for resolving @id in LLM output (distinguishes user vs agent)
+  const mentionIdMap = new Map<string, "user" | "agent">();
+  if (mentionIds) {
+    for (const id of mentionIds.userIds) {
+      mentionIdMap.set(id.toLowerCase(), "user");
+    }
+    for (const id of mentionIds.agentIds) {
+      mentionIdMap.set(String(id).toLowerCase(), "agent");
+    }
+  }
+
   const deliver = async (payload: ReplyPayload) => {
     const text = payload.text ?? "";
+    logVerbose(`[infoflow] deliver called: to=${to}, text=${text}`);
     if (!text.trim()) {
       return;
     }
 
+    // Resolve @id patterns in LLM output text to user/agent IDs
+    const resolvedUserIds: string[] = [];
+    const resolvedAgentIds: number[] = [];
+    if (isGroup && mentionIdMap.size > 0) {
+      const mentionPattern = /@([\w.]+)/g;
+      let match: RegExpExecArray | null;
+      while ((match = mentionPattern.exec(text)) !== null) {
+        const id = match[1];
+        const type = mentionIdMap.get(id.toLowerCase());
+        if (type === "user" && !resolvedUserIds.includes(id)) {
+          resolvedUserIds.push(id);
+        } else if (type === "agent") {
+          const numId = Number(id);
+          if (Number.isFinite(numId) && !resolvedAgentIds.includes(numId)) {
+            resolvedAgentIds.push(numId);
+          }
+        }
+      }
+    }
+
+    // Merge atOptions user IDs (sender echo-back) with LLM-resolved user IDs
+    const atOptionIds = atOptions?.atAll ? [] : (atOptions?.atUserIds ?? []);
+    const allAtUserIds = [...atOptionIds];
+    for (const id of resolvedUserIds) {
+      if (!allAtUserIds.includes(id)) {
+        allAtUserIds.push(id);
+      }
+    }
+    const hasAtAll = atOptions?.atAll === true;
+    const hasAtUsers = allAtUserIds.length > 0;
+    const hasAtAgents = resolvedAgentIds.length > 0;
+
+    // Prepend AT mentions to the text if needed (group messages only)
+    // Only prepend for atOptions IDs; LLM text already contains @id for resolved mentions
+    let messageText = text;
+    if (isGroup && atOptions) {
+      let atPrefix = "";
+      if (hasAtAll) {
+        atPrefix = "@all ";
+      } else if (atOptions.atUserIds?.length) {
+        atPrefix = atOptions.atUserIds.map((id) => `@${id}`).join(" ") + " ";
+      }
+      messageText = atPrefix + text;
+    }
+
     // Chunk text to 4000 chars max (Infoflow limit)
-    const chunks = core.channel.text.chunkText(text, 4000);
+    const chunks = core.channel.text.chunkText(messageText, 4000);
     // Only include @mentions in the first chunk (avoid duplicate @s)
     let isFirstChunk = true;
 
     for (const chunk of chunks) {
-      const contents: InfoflowMessageContentItem[] = [{ type: "markdown", content: chunk }];
+      const contents: InfoflowMessageContentItem[] = [];
 
-      // Add AT content for group messages (first chunk only)
-      if (isFirstChunk && isGroup && atOptions) {
-        if (atOptions.atAll) {
+      // Add AT content nodes for group messages (first chunk only)
+      if (isFirstChunk && isGroup) {
+        if (hasAtAll) {
           contents.push({ type: "at", content: "all" });
-        } else if (atOptions.atUserIds?.length) {
-          contents.push({ type: "at", content: atOptions.atUserIds.join(",") });
+        } else if (hasAtUsers) {
+          contents.push({ type: "at", content: allAtUserIds.join(",") });
+        }
+        if (hasAtAgents) {
+          contents.push({ type: "at-agent", content: resolvedAgentIds.join(",") });
         }
       }
       isFirstChunk = false;
 
+      // Add markdown content
+      contents.push({ type: "markdown", content: chunk });
+
       const result = await sendInfoflowMessage({ cfg, to, contents, accountId });
 
       if (result.ok) {
         statusSink?.({ lastOutboundAt: Date.now() });
       } else if (result.error) {
-        getInfoflowSendLog().error(`[infoflow] Failed to send message: ${result.error}`);
+        getInfoflowSendLog().error(
+          `[infoflow] reply failed to=${to}, accountId=${accountId}: ${result.error}`,
+        );
       }
     }
   };
 
   const onError = (err: unknown) => {
-    getInfoflowSendLog().error(`[infoflow] reply failed: ${String(err)}`);
+    getInfoflowSendLog().error(
+      `[infoflow] reply error to=${to}, accountId=${accountId}: ${formatInfoflowError(err)}`,
+    );
   };
 
   return {

package/src/send.ts

@@ -7,8 +7,7 @@ import { createHash, randomUUID } from "node:crypto";
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
 import { resolveInfoflowAccount } from "./accounts.js";
 import { recordSentMessageId } from "./infoflow-req-parse.js";
-import { getInfoflowSendLog } from "./logging.js";
-import { getInfoflowRuntime } from "./runtime.js";
+import { getInfoflowSendLog, formatInfoflowError, logVerbose } from "./logging.js";
 import type {
   InfoflowGroupMessageBodyItem,
   InfoflowMessageContentItem,
@@ -163,7 +162,7 @@ export async function getAppAccessToken(params: {
 
     return { ok: true, token };
   } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
+    const errMsg = formatInfoflowError(err);
     return { ok: false, error: errMsg };
   } finally {
     clearTimeout(timeout);
@@ -275,10 +274,15 @@ export async function sendInfoflowPrivateMessage(params: {
       LOGID: randomUUID(),
     };
 
+    const bodyStr = JSON.stringify(payload);
+
+    // Log request body when verbose logging is enabled
+    logVerbose(`[infoflow:sendPrivate] POST body: ${bodyStr}`);
+
     const res = await fetch(`${ensureHttps(apiHost)}${INFOFLOW_PRIVATE_SEND_PATH}`, {
       method: "POST",
       headers,
-      body: JSON.stringify(payload),
+      body: bodyStr,
       signal: controller.signal,
     });
 
@@ -313,7 +317,7 @@ export async function sendInfoflowPrivateMessage(params: {
 
     return { ok: true, invaliduser: innerData?.invaliduser as string | undefined, msgkey };
   } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
+    const errMsg = formatInfoflowError(err);
     getInfoflowSendLog().error(`[infoflow:sendPrivate] exception: ${errMsg}`);
     return { ok: false, error: errMsg };
   } finally {
@@ -379,6 +383,15 @@ export async function sendInfoflowGroupMessage(params: {
         const { href } = parseLinkContent(item.content);
         body.push({ type: "LINK", href });
       }
+    } else if (type === "at-agent") {
+      // Robot AT: parse comma-separated numeric IDs into atagentids
+      const agentIds = item.content
+        .split(",")
+        .map((s) => Number(s.trim()))
+        .filter(Number.isFinite);
+      if (agentIds.length > 0) {
+        body.push({ type: "AT", atuserids: [], atagentids: agentIds });
+      }
     }
   }
 
@@ -417,10 +430,15 @@ export async function sendInfoflowGroupMessage(params: {
       "Content-Type": "application/json",
     };
 
+    const bodyStr = JSON.stringify(payload);
+
+    // Log request body when verbose logging is enabled
+    logVerbose(`[infoflow:sendGroup] POST body: ${bodyStr}`);
+
     const res = await fetch(`${ensureHttps(apiHost)}${INFOFLOW_GROUP_SEND_PATH}`, {
       method: "POST",
       headers,
-      body: JSON.stringify(payload),
+      body: bodyStr,
       signal: controller.signal,
     });
 
@@ -452,7 +470,7 @@ export async function sendInfoflowGroupMessage(params: {
 
     return { ok: true, messageid };
   } catch (err) {
-    const errMsg = err instanceof Error ? err.message : String(err);
+    const errMsg = formatInfoflowError(err);
     getInfoflowSendLog().error(`[infoflow:sendGroup] exception: ${errMsg}`);
     return { ok: false, error: errMsg };
   } finally {

package/src/targets.ts

@@ -3,8 +3,7 @@
  * Handles user and group ID formats for message targeting.
  */
 
-import { getInfoflowSendLog } from "./logging.js";
-import { getInfoflowRuntime } from "./runtime.js";
+import { logVerbose } from "./logging.js";
 
 // ---------------------------------------------------------------------------
 // Target Format Constants
@@ -33,23 +32,11 @@ const USER_PREFIX = "user:";
  *   "123456" -> "group:123456" (pure digits treated as group)
  */
 export function normalizeInfoflowTarget(raw: string): string | undefined {
-  // Get verbose state once at start
-  let verbose = false;
-  try {
-    verbose = getInfoflowRuntime().logging.shouldLogVerbose();
-  } catch {
-    // runtime not available, keep verbose = false
-  }
-
-  if (verbose) {
-    getInfoflowSendLog().debug?.(`[infoflow:normalizeTarget] input: "${raw}"`);
-  }
+  logVerbose(`[infoflow:normalizeTarget] input: "${raw}"`);
 
   const trimmed = raw.trim();
   if (!trimmed) {
-    if (verbose) {
-      getInfoflowSendLog().debug?.(`[infoflow:normalizeTarget] empty input, returning undefined`);
-    }
+    logVerbose(`[infoflow:normalizeTarget] empty input, returning undefined`);
     return undefined;
   }
 
@@ -63,27 +50,19 @@ export function normalizeInfoflowTarget(raw: string): string | undefined {
 
   // Keep group: prefix as-is
   if (target.toLowerCase().startsWith(GROUP_PREFIX)) {
-    if (verbose) {
-      getInfoflowSendLog().debug?.(`[infoflow:normalizeTarget] output: "${target}" (group)`);
-    }
+    logVerbose(`[infoflow:normalizeTarget] output: "${target}" (group)`);
     return target;
   }
 
   // Pure digits -> treat as group ID
   if (/^\d+$/.test(target)) {
     const result = `${GROUP_PREFIX}${target}`;
-    if (verbose) {
-      getInfoflowSendLog().debug?.(
-        `[infoflow:normalizeTarget] output: "${result}" (digits -> group)`,
-      );
-    }
+    logVerbose(`[infoflow:normalizeTarget] output: "${result}" (digits -> group)`);
     return result;
   }
 
   // Otherwise it's a username
-  if (verbose) {
-    getInfoflowSendLog().debug?.(`[infoflow:normalizeTarget] output: "${target}" (username)`);
-  }
+  logVerbose(`[infoflow:normalizeTarget] output: "${target}" (username)`);
   return target;
 }
 

package/src/types.ts

@@ -10,6 +10,48 @@ export type InfoflowDmPolicy = "open" | "pairing" | "allowlist";
 export type InfoflowGroupPolicy = "open" | "allowlist" | "disabled";
 export type InfoflowChatType = "direct" | "group";
 
+/** Reply mode controlling bot behavior per group */
+export type InfoflowReplyMode =
+  | "ignore"
+  | "record"
+  | "mention-only"
+  | "mention-and-watch"
+  | "proactive";
+
+/** Per-group configuration overrides */
+export type InfoflowGroupConfig = {
+  replyMode?: InfoflowReplyMode;
+  watchMentions?: string[];
+  followUp?: boolean;
+  followUpWindow?: number;
+  systemPrompt?: string;
+};
+
+// ---------------------------------------------------------------------------
+// Inbound body item (for @mention detection in received messages)
+// ---------------------------------------------------------------------------
+
+/** Inbound body item from group messages (for @mention detection) */
+export type InfoflowInboundBodyItem = {
+  type?: string;
+  content?: string;
+  label?: string;
+  /** 机器人 AT 时有此字段（数字），与 userid 互斥 */
+  robotid?: number;
+  /** AT 元素的显示名称 */
+  name?: string;
+  /** 人类用户 AT 时有此字段（uuap name），与 robotid 互斥 */
+  userid?: string;
+};
+
+/** Mention IDs extracted from inbound group AT items (excluding the bot itself) */
+export type InfoflowMentionIds = {
+  /** Human user userid list */
+  userIds: string[];
+  /** Robot robotid list (numbers, corresponding to outbound atagentids) */
+  agentIds: number[];
+};
+
 // ---------------------------------------------------------------------------
 // AT mention types
 // ---------------------------------------------------------------------------
@@ -26,12 +68,12 @@ export type InfoflowAtOptions = {
 export type InfoflowGroupMessageBodyItem =
   | { type: "TEXT"; content: string }
   | { type: "MD"; content: string }
-  | { type: "AT"; atall?: boolean; atuserids: string[] }
+  | { type: "AT"; atall?: boolean; atuserids: string[]; atagentids?: number[] }
   | { type: "LINK"; href: string };
 
 /** Content item for sendInfoflowMessage */
 export type InfoflowMessageContentItem = {
-  type: "text" | "markdown" | "at" | "link";
+  type: "text" | "markdown" | "at" | "at-agent" | "link";
   content: string;
 };
 
@@ -54,6 +96,17 @@ export type InfoflowAccountConfig = {
   requireMention?: boolean;
   /** Robot name for matching @mentions in group messages */
   robotName?: string;
+  /** Names to watch for @mentions; when someone @mentions a person in this list,
+   *  the bot analyzes the message and replies only if confident. */
+  watchMentions?: string[];
+  /** Reply mode controlling bot engagement level in groups */
+  replyMode?: InfoflowReplyMode;
+  /** Enable follow-up replies after bot responds to a mention (default: true) */
+  followUp?: boolean;
+  /** Follow-up window in seconds after last bot reply (default: 300) */
+  followUpWindow?: number;
+  /** Per-group configuration overrides, keyed by group ID */
+  groups?: Record<string, InfoflowGroupConfig>;
   accounts?: Record<string, InfoflowAccountConfig>;
   defaultAccount?: string;
 };
@@ -78,6 +131,17 @@ export type ResolvedInfoflowAccount = {
     requireMention?: boolean;
     /** Robot name for matching @mentions in group messages */
     robotName?: string;
+    /** Names to watch for @mentions; when someone @mentions a person in this list,
+     *  the bot analyzes the message and replies only if confident. */
+    watchMentions?: string[];
+    /** Reply mode controlling bot engagement level in groups */
+    replyMode?: InfoflowReplyMode;
+    /** Enable follow-up replies after bot responds to a mention (default: true) */
+    followUp?: boolean;
+    /** Follow-up window in seconds after last bot reply (default: 300) */
+    followUpWindow?: number;
+    /** Per-group configuration overrides, keyed by group ID */
+    groups?: Record<string, InfoflowGroupConfig>;
   };
 };
 
@@ -99,6 +163,12 @@ export type InfoflowMessageEvent = {
   timestamp?: number;
   /** Raw message text preserving @mentions (for RawBody) */
   rawMes?: string;
+  /** Raw body items from group message (for watch-mention detection) */
+  bodyItems?: InfoflowInboundBodyItem[];
+  /** Non-bot mention IDs extracted from AT items in group messages (excluding bot itself) */
+  mentionIds?: InfoflowMentionIds;
+  /** Reply/quote context extracted from replyData body items (supports multiple quotes) */
+  replyContext?: string[];
 };
 
 // ---------------------------------------------------------------------------