@chbo297/infoflow 2026.3.18 → 2026.5.4

package/src/bot.ts

@@ -1,12 +1,14 @@
+import {
+  buildAgentMediaPayload,
+  getAgentScopedMediaLocalRoots,
+} from "openclaw/plugin-sdk/agent-media-payload";
 import {
   buildPendingHistoryContextFromMap,
   clearHistoryEntriesIfEnabled,
   DEFAULT_GROUP_HISTORY_LIMIT,
   type HistoryEntry,
   recordPendingHistoryEntryIfEnabled,
-  buildAgentMediaPayload,
-} from "openclaw/plugin-sdk";
-import { getAgentScopedMediaLocalRoots } from "openclaw/plugin-sdk/mattermost";
+} from "openclaw/plugin-sdk/reply-history";
 import { resolveInfoflowAccount } from "./accounts.js";
 import { getInfoflowBotLog, formatInfoflowError, logVerbose } from "./logging.js";
 import { createInfoflowReplyDispatcher } from "./reply-dispatcher.js";
@@ -52,34 +54,62 @@ type InfoflowBodyItem = {
   messageid?: string | number;
 };
 
+/** Identity used to detect @bot in group body (name, app agent id, or persisted robot id). */
+export type InfoflowBotMentionIdentity = {
+  robotName?: string;
+  appAgentId?: number;
+  robotId?: string;
+};
+
 /**
  * Check if the bot was @mentioned in the message body.
- * Matches by robotName against the AT item's display name (case-insensitive).
+ * Matches appAgentId, robotName, or robotId against AT items (same order as Baidu reference plugin).
  */
-function checkBotMentioned(bodyItems: InfoflowBodyItem[], robotName?: string): boolean {
-  if (!robotName) return false;
-  const normalizedRobotName = robotName.toLowerCase();
+export function checkBotMentioned(
+  bodyItems: InfoflowBodyItem[],
+  identityOrName?: string | InfoflowBotMentionIdentity,
+): boolean {
+  const identity: InfoflowBotMentionIdentity =
+    typeof identityOrName === "string" || identityOrName === undefined
+      ? { robotName: identityOrName }
+      : identityOrName;
+  const { robotName, appAgentId, robotId } = identity;
+  const appAgentIdStr = appAgentId != null ? String(appAgentId) : undefined;
+  const normalizedRobotName = robotName?.toLowerCase();
+  const normalizedRobotId = robotId?.trim();
   for (const item of bodyItems) {
     if (item.type !== "AT") continue;
-    if (item.name?.toLowerCase() === normalizedRobotName) return true;
+    if (appAgentIdStr && item.robotid != null && String(item.robotid) === appAgentIdStr)
+      return true;
+    if (normalizedRobotName && item.name?.toLowerCase() === normalizedRobotName) return true;
+    if (normalizedRobotId && item.robotid != null && String(item.robotid) === normalizedRobotId)
+      return true;
   }
   return false;
 }
 
 /**
- * When the bot is @mentioned (item.name matches robotName), return that AT item's robotid.
- * Used to discover and persist the account's robotId from incoming group messages.
+ * When the bot is @mentioned, return that AT item's robotid string for persistence.
  */
 function getBotRobotidFromBody(
   bodyItems: InfoflowBodyItem[],
   robotName?: string,
-): number | undefined {
-  if (!robotName) return undefined;
-  const normalizedRobotName = robotName.toLowerCase();
+  robotId?: string,
+): string | undefined {
+  const normalizedRobotName = robotName?.toLowerCase();
+  const normalizedRobotId = robotId?.trim();
   for (const item of bodyItems) {
     if (item.type !== "AT") continue;
-    if (item.name?.toLowerCase() === normalizedRobotName && item.robotid != null)
-      return item.robotid;
+    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;
 }
@@ -557,14 +587,27 @@ export async function handleGroupChatMessage(params: HandleGroupChatParams): Pro
   const account = resolveInfoflowAccount({ cfg, accountId });
   const robotName = account.config.robotName;
 
-  // Check if bot was @mentioned (by robotName)
-  const wasMentioned = checkBotMentioned(bodyItems, robotName);
+  const mentionIdentity: InfoflowBotMentionIdentity = {
+    robotName,
+    appAgentId: account.config.appAgentId,
+    robotId: account.config.robotId?.trim() || undefined,
+  };
+
+  const rawEventType = String(msgData.eventtype ?? "");
+  const wasMentioned =
+    msgData.wasMentioned === true
+      ? true
+      : rawEventType === "ALL_MESSAGE_FORWARD"
+        ? checkBotMentioned(bodyItems, mentionIdentity)
+        : rawEventType === "MESSAGE_RECEIVE"
+          ? true
+          : checkBotMentioned(bodyItems, mentionIdentity);
 
   // When bot is @mentioned, discover and persist robotId from the AT item so we can ignore our own messages later.
   let effectiveRobotId = account.config.robotId?.trim() || undefined;
-  const discoveredRobotid = getBotRobotidFromBody(bodyItems, robotName);
-  if (wasMentioned && discoveredRobotid != null) {
-    const newRobotId = String(discoveredRobotid);
+  const discoveredRobotId = getBotRobotidFromBody(bodyItems, robotName, effectiveRobotId);
+  if (wasMentioned && discoveredRobotId != null) {
+    const newRobotId = discoveredRobotId;
     if (newRobotId !== effectiveRobotId) {
       try {
         const runtime = getInfoflowRuntime();

package/src/channel.ts

@@ -1,3 +1,4 @@
+import type { ChannelPlugin, OpenClawConfig } from "openclaw/plugin-sdk";
 import {
   applyAccountNameToChannelSection,
   DEFAULT_ACCOUNT_ID,
@@ -6,9 +7,7 @@ import {
   migrateBaseNameToDefaultAccount,
   normalizeAccountId,
   setAccountEnabledInConfigSection,
-  type ChannelPlugin,
-  type OpenClawConfig,
-} from "openclaw/plugin-sdk";
+} from "openclaw/plugin-sdk/core";
 import {
   getChannelSection,
   listInfoflowAccountIds,
@@ -19,20 +18,68 @@ 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 { startInfoflowMonitor, startInfoflowWSMonitor } from "./monitor.js";
 import { getInfoflowRuntime } from "./runtime.js";
 import { sendInfoflowMessage } from "./send.js";
 import { normalizeInfoflowTarget, looksLikeInfoflowId } from "./targets.js";
 import type { InfoflowOutboundReply, ResolvedInfoflowAccount } from "./types.js";
 
 // Re-export types and account functions for external consumers
-export type { InfoflowAccountConfig, ResolvedInfoflowAccount } from "./types.js";
+export type {
+  InfoflowAccountConfig,
+  InfoflowConnectionMode,
+  ResolvedInfoflowAccount,
+} from "./types.js";
 export { resolveInfoflowAccount } from "./accounts.js";
 
 // ---------------------------------------------------------------------------
 // Channel plugin
 // ---------------------------------------------------------------------------
 
+function applyInfoflowSetupPatch(params: {
+  cfg: OpenClawConfig;
+  accountId: string;
+  patch: Record<string, unknown>;
+}): OpenClawConfig {
+  const { cfg, accountId, patch } = params;
+  const channels = (cfg.channels ?? {}) as Record<string, unknown>;
+  const existingInfoflow = (channels["infoflow"] ?? {}) as Record<string, unknown>;
+
+  if (accountId === DEFAULT_ACCOUNT_ID) {
+    return {
+      ...cfg,
+      channels: {
+        ...channels,
+        infoflow: {
+          ...existingInfoflow,
+          enabled: true,
+          ...patch,
+        },
+      },
+    };
+  }
+
+  const existingAccounts = (existingInfoflow.accounts ?? {}) as Record<string, Record<string, unknown>>;
+  return {
+    ...cfg,
+    channels: {
+      ...channels,
+      infoflow: {
+        ...existingInfoflow,
+        enabled: true,
+        accounts: {
+          ...existingAccounts,
+          [accountId]: {
+            ...existingAccounts[accountId],
+            enabled: true,
+            ...patch,
+          },
+        },
+      },
+    },
+  };
+}
+
 export const infoflowPlugin: ChannelPlugin<ResolvedInfoflowAccount> = {
   id: "infoflow",
   meta: {
@@ -96,7 +143,7 @@ export const infoflowPlugin: ChannelPlugin<ResolvedInfoflowAccount> = {
         policy: ((account.config as Record<string, unknown>).dmPolicy as string) ?? "open",
         allowFrom: ((account.config as Record<string, unknown>).allowFrom as string[]) ?? [],
         policyPath: `${basePath}dmPolicy`,
-        allowFromPath: basePath,
+        allowFromPath: `${basePath}allowFrom`,
         approveHint: formatPairingApproveHint("infoflow"),
         normalizeEntry: (raw: string) => raw.replace(/^infoflow:/i, ""),
       };
@@ -169,40 +216,7 @@ export const infoflowPlugin: ChannelPlugin<ResolvedInfoflowAccount> = {
       if (input.token) {
         patch.checkToken = input.token;
       }
-
-      const existing = (next.channels?.["infoflow"] ?? {}) as Record<string, unknown>;
-      if (accountId === DEFAULT_ACCOUNT_ID) {
-        return {
-          ...next,
-          channels: {
-            ...next.channels,
-            infoflow: {
-              ...existing,
-              enabled: true,
-              ...patch,
-            },
-          },
-        } as OpenClawConfig;
-      }
-      const existingAccounts = (existing.accounts ?? {}) as Record<string, Record<string, unknown>>;
-      return {
-        ...next,
-        channels: {
-          ...next.channels,
-          infoflow: {
-            ...existing,
-            enabled: true,
-            accounts: {
-              ...existingAccounts,
-              [accountId]: {
-                ...existingAccounts[accountId],
-                enabled: true,
-                ...patch,
-              },
-            },
-          },
-        },
-      } as OpenClawConfig;
+      return applyInfoflowSetupPatch({ cfg: next, accountId, patch });
     },
   },
   outbound: {
@@ -390,19 +404,24 @@ export const infoflowPlugin: ChannelPlugin<ResolvedInfoflowAccount> = {
   gateway: {
     startAccount: async (ctx) => {
       const account = ctx.account;
-      ctx.log?.info(`[${account.accountId}] starting Infoflow webhook`);
+      const connectionMode = account.config.connectionMode ?? "webhook";
+      ctx.log?.info(`[${account.accountId}] starting Infoflow (${connectionMode})`);
       ctx.setStatus({
         accountId: account.accountId,
         running: true,
         lastStartAt: Date.now(),
       });
-      const unregister = await startInfoflowMonitor({
+      const monitorOptions = {
         account,
         config: ctx.cfg,
-        runtime: ctx.runtime,
         abortSignal: ctx.abortSignal,
-        statusSink: (patch) => ctx.setStatus({ accountId: account.accountId, ...patch }),
-      });
+        statusSink: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) =>
+          ctx.setStatus({ accountId: account.accountId, ...patch }),
+      };
+      const unregister =
+        connectionMode === "websocket"
+          ? await startInfoflowWSMonitor(monitorOptions)
+          : await startInfoflowMonitor(monitorOptions);
 
       // Keep the channel alive until explicitly stopped.
       // Without this, the promise resolves immediately and the gateway

package/src/infoflow-req-parse.ts

@@ -1,7 +1,7 @@
 import { createHash, createDecipheriv, timingSafeEqual } from "node:crypto";
 import type { IncomingMessage } from "node:http";
 import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { createDedupeCache } from "openclaw/plugin-sdk";
+import { createDedupeCache } from "openclaw/plugin-sdk/core";
 // ---------------------------------------------------------------------------
 // Message deduplication
 // ---------------------------------------------------------------------------
@@ -98,7 +98,7 @@ function extractDedupeKey(msgData: Record<string, unknown>): string | null {
  * Returns true if the message is a duplicate (already seen within TTL).
  * Uses shared dedupe cache implementation.
  */
-function isDuplicateMessage(msgData: Record<string, unknown>): boolean {
+export function isDuplicateMessage(msgData: Record<string, unknown>): boolean {
   const key = extractDedupeKey(msgData);
   if (!key) return false; // Cannot extract key, allow through
 

package/src/infoflow-sdk.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Ambient types when `@baidu/infoflow-sdk-nodejs` is not installed (e.g. public npm).
+ * Install the SDK from Baidu's registry to use `connectionMode: "websocket"`.
+ */
+declare module "@baidu/infoflow-sdk-nodejs" {
+  export class WSClient {
+    constructor(options: Record<string, unknown>);
+    on(event: string, handler: (...args: unknown[]) => void): void;
+    connect(): Promise<void>;
+    disconnect(): void;
+  }
+}

package/src/monitor.ts

@@ -8,6 +8,7 @@ import {
 } from "./infoflow-req-parse.js";
 import { getInfoflowWebhookLog, formatInfoflowError, logVerbose } from "./logging.js";
 import { getInfoflowRuntime } from "./runtime.js";
+import { InfoflowWSReceiver } from "./ws-receiver.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -16,7 +17,6 @@ import { getInfoflowRuntime } from "./runtime.js";
 export type InfoflowMonitorOptions = {
   account: ResolvedInfoflowAccount;
   config: OpenClawConfig;
-  runtime: unknown;
   abortSignal: AbortSignal;
   statusSink?: (patch: { lastInboundAt?: number; lastOutboundAt?: number }) => void;
 };
@@ -79,7 +79,7 @@ function isInfoflowPath(requestPath: string): boolean {
 /**
  * Handles incoming Infoflow webhook HTTP requests.
  *
- * - Routes by path to registered targets (supports exact and suffix match).
+ * - Routes by path to registered targets (exact match).
  * - Only allows POST.
  * - Delegates body reading, echostr verification, authentication,
  *   and message dispatch to infoflow_req_parse.
@@ -167,3 +167,22 @@ export async function startInfoflowMonitor(options: InfoflowMonitorOptions): Pro
 
   return unregister;
 }
+
+/** Starts a WebSocket message receiver and returns a stop function. */
+export async function startInfoflowWSMonitor(options: InfoflowMonitorOptions): Promise<() => void> {
+  const receiver = new InfoflowWSReceiver({
+    account: options.account,
+    config: options.config,
+    abortSignal: options.abortSignal,
+    statusSink: options.statusSink,
+  });
+
+  try {
+    await receiver.start();
+  } catch (err) {
+    receiver.stop();
+    throw err;
+  }
+
+  return () => receiver.stop();
+}

package/src/reply-dispatcher.ts

@@ -1,8 +1,5 @@
-import {
-  createReplyPrefixOptions,
-  type OpenClawConfig,
-  type ReplyPayload,
-} from "openclaw/plugin-sdk";
+import type { OpenClawConfig, ReplyPayload } from "openclaw/plugin-sdk";
+import { createReplyPrefixOptions } from "openclaw/plugin-sdk/channel-reply-pipeline";
 import { getInfoflowSendLog, formatInfoflowError, logVerbose } from "./logging.js";
 import { parseMarkdownForLocalImages } from "./markdown-local-images.js";
 import { prepareInfoflowImageBase64, sendInfoflowImageMessage } from "./media.js";

package/src/types.ts

@@ -10,6 +10,9 @@ export type InfoflowDmPolicy = "open" | "pairing" | "allowlist";
 export type InfoflowGroupPolicy = "open" | "allowlist" | "disabled";
 export type InfoflowChatType = "direct" | "group";
 
+/** Inbound message transport: webhook (Infoflow POSTs to your server) or websocket (plugin connects to gateway). */
+export type InfoflowConnectionMode = "webhook" | "websocket";
+
 /** Reply mode controlling bot behavior per group */
 export type InfoflowReplyMode =
   | "ignore"
@@ -101,6 +104,11 @@ export type InfoflowAccountConfig = {
   enabled?: boolean;
   name?: string;
   apiHost?: string;
+  connectionMode?: InfoflowConnectionMode;
+  /** WebSocket gateway host (websocket mode). */
+  wsGateway?: string;
+  /** Override WebSocket handshake host (optional, intranet). */
+  wsConnectDomain?: string;
   checkToken?: string;
   encodingAESKey?: string;
   appKey?: string;
@@ -142,6 +150,9 @@ export type ResolvedInfoflowAccount = {
     enabled?: boolean;
     name?: string;
     apiHost: string;
+    connectionMode: InfoflowConnectionMode;
+    wsGateway: string;
+    wsConnectDomain?: string;
     checkToken: string;
     encodingAESKey: string;
     appKey: string;