@chbo297/infoflow 2026.3.4 → 2026.3.7

package/src/bot.ts

@@ -1,3 +1,11 @@
+import {
+  buildPendingHistoryContextFromMap,
+  clearHistoryEntriesIfEnabled,
+  DEFAULT_GROUP_HISTORY_LIMIT,
+  type HistoryEntry,
+  recordPendingHistoryEntryIfEnabled,
+  buildAgentMediaPayload,
+} from "openclaw/plugin-sdk";
 import { resolveInfoflowAccount } from "./accounts.js";
 import { getInfoflowBotLog, formatInfoflowError, logVerbose } from "./logging.js";
 import { createInfoflowReplyDispatcher } from "./reply-dispatcher.js";
@@ -36,6 +44,8 @@ type InfoflowBodyItem = {
   name?: string;
   /** 人类用户 AT 时有此字段（uuap name），与 robotid 互斥 */
   userid?: string;
+  /** IMAGE 类型 body item 的图片下载地址 */
+  downloadurl?: string;
 };
 
 /**
@@ -219,6 +229,9 @@ function buildProactivePrompt(): string {
 /** In-memory map tracking bot's last reply timestamp per group */
 const groupLastReplyMap = new Map<string, number>();
 
+/** In-memory map accumulating recent group messages for context injection when bot is @mentioned */
+const chatHistories = new Map<string, HistoryEntry[]>();
+
 /** Record that the bot replied to a group (called after successful send) */
 export function recordGroupReply(groupId: string): void {
   groupLastReplyMap.set(groupId, Date.now());
@@ -290,24 +303,39 @@ export async function handlePrivateChatMessage(params: HandlePrivateChatParams):
   const createTime = msgData.CreateTime ?? msgData.createtime;
   const timestamp = createTime != null ? Number(createTime) * 1000 : Date.now();
 
+  // Detect image messages: MsgType=image with PicUrl
+  const msgType = String(msgData.MsgType ?? msgData.msgtype ?? "");
+  const picUrl = String(msgData.PicUrl ?? msgData.picurl ?? "");
+  const imageUrls: string[] = [];
+  if (msgType === "image" && picUrl.trim()) {
+    imageUrls.push(picUrl.trim());
+  }
+
   logVerbose(
-    `[infoflow] private chat: fromuser=${fromuser}, senderName=${senderName}, raw msgData: ${JSON.stringify(msgData)}`,
+    `[infoflow] private chat: fromuser=${fromuser}, senderName=${senderName}, mes=${mes}, msgType=${msgType}, raw msgData: ${JSON.stringify(msgData)}`,
   );
 
-  if (!fromuser || !mes.trim()) {
+  if (!fromuser || (!mes.trim() && imageUrls.length === 0)) {
     return;
   }
 
+  // For image-only messages (no text), use placeholder
+  let effectiveMes = mes.trim();
+  if (!effectiveMes && imageUrls.length > 0) {
+    effectiveMes = "<media:image>";
+  }
+
   // Delegate to the common message handler (private chat)
   await handleInfoflowMessage({
     cfg,
     event: {
       fromuser,
-      mes,
+      mes: effectiveMes,
       chatType: "direct",
       senderName,
       messageId: messageIdStr,
       timestamp,
+      imageUrls: imageUrls.length > 0 ? imageUrls : undefined,
     },
     accountId,
     statusSink,
@@ -365,6 +393,7 @@ export async function handleGroupChatMessage(params: HandleGroupChatParams): Pro
   let textContent = "";
   let rawTextContent = "";
   const replyContextItems: string[] = [];
+  const imageUrls: string[] = [];
   if (Array.isArray(bodyItems)) {
     for (const item of bodyItems) {
       if (item.type === "replyData") {
@@ -388,6 +417,12 @@ export async function handleGroupChatMessage(params: HandleGroupChatParams): Pro
         if (name) {
           rawTextContent += `@${name} `;
         }
+      } else if (item.type === "IMAGE") {
+        // 提取图片下载地址
+        const url = item.downloadurl;
+        if (typeof url === "string" && url.trim()) {
+          imageUrls.push(url.trim());
+        }
       }
     }
   }
@@ -397,9 +432,13 @@ export async function handleGroupChatMessage(params: HandleGroupChatParams): Pro
 
   const replyContext = replyContextItems.length > 0 ? replyContextItems : undefined;
 
-  if (!mes && !replyContext) {
+  if (!mes && !replyContext && imageUrls.length === 0) {
     return;
   }
+  // 纯图片消息：设置占位符
+  if (!mes && imageUrls.length > 0) {
+    mes = `<media:image>${imageUrls.length > 1 ? ` (${imageUrls.length} images)` : ""}`;
+  }
   // If mes is empty but replyContext exists, use a placeholder so the message is not dropped
   if (!mes && replyContext) {
     mes = "(引用回复)";
@@ -425,6 +464,7 @@ export async function handleGroupChatMessage(params: HandleGroupChatParams): Pro
       mentionIds:
         mentionIds.userIds.length > 0 || mentionIds.agentIds.length > 0 ? mentionIds : undefined,
       replyContext,
+      imageUrls: imageUrls.length > 0 ? imageUrls : undefined,
     },
     accountId,
     statusSink,
@@ -477,7 +517,7 @@ export async function handleInfoflowMessage(params: HandleInfoflowMessageParams)
   // Build conversation label and from address based on chat type
   const fromLabel = isGroup ? `group:${groupId}` : senderName || fromuser;
   const fromAddress = isGroup ? `infoflow:group:${groupId}` : `infoflow:${fromuser}`;
-  const toAddress = isGroup ? `infoflow:${groupId}` : `infoflow:${account.accountId}`;
+  const toAddress = isGroup ? `infoflow:group:${groupId}` : `infoflow:${fromuser}`;
 
   const body = core.channel.reply.formatAgentEnvelope({
     channel: "Infoflow",
@@ -488,8 +528,116 @@ export async function handleInfoflowMessage(params: HandleInfoflowMessageParams)
     body: mes,
   });
 
+  // Inject accumulated group chat history into the body for context
+  const historyKey = isGroup && groupId !== undefined ? String(groupId) : undefined;
+  let combinedBody = body;
+  if (isGroup && historyKey) {
+    combinedBody = buildPendingHistoryContextFromMap({
+      historyMap: chatHistories,
+      historyKey,
+      limit: DEFAULT_GROUP_HISTORY_LIMIT,
+      currentMessage: body,
+      formatEntry: (entry) =>
+        core.channel.reply.formatAgentEnvelope({
+          channel: "Infoflow",
+          from: entry.sender,
+          timestamp: entry.timestamp ?? Date.now(),
+          body: entry.body,
+        }),
+    });
+  }
+
+  const inboundHistory =
+    isGroup && historyKey
+      ? (chatHistories.get(historyKey) ?? []).map((e) => ({
+          sender: e.sender,
+          body: e.body,
+          timestamp: e.timestamp,
+        }))
+      : undefined;
+
+  // --- Resolve inbound media (images) ---
+  const INFOFLOW_MAX_IMAGES = 20;
+  const mediaMaxBytes = 30 * 1024 * 1024; // 30MB default, matching Feishu
+  const mediaList: Array<{ path: string; contentType?: string }> = [];
+  const failReasons: string[] = [];
+
+  if (event.imageUrls && event.imageUrls.length > 0) {
+    // Collect unique hostnames from image URLs for SSRF allowlist.
+    // Infoflow image servers (e.g. xp2.im.baidu.com, e4hi.im.baidu.com) resolve to
+    // internal IPs on Baidu's network, so they need to be explicitly allowed.
+    const allowedHostnames: string[] = [];
+    for (const imageUrl of event.imageUrls) {
+      try {
+        const hostname = new URL(imageUrl).hostname;
+        if (hostname && !allowedHostnames.includes(hostname)) {
+          allowedHostnames.push(hostname);
+        }
+      } catch {
+        // invalid URL, will fail at fetch time
+      }
+    }
+    const ssrfPolicy = allowedHostnames.length > 0 ? { allowedHostnames } : undefined;
+
+    const urls = event.imageUrls.slice(0, INFOFLOW_MAX_IMAGES);
+    const results = await Promise.allSettled(
+      urls.map(async (imageUrl) => {
+        const fetched = await core.channel.media.fetchRemoteMedia({
+          url: imageUrl,
+          maxBytes: mediaMaxBytes,
+          ssrfPolicy,
+        });
+        const saved = await core.channel.media.saveMediaBuffer(
+          fetched.buffer,
+          fetched.contentType ?? undefined,
+          "inbound",
+          mediaMaxBytes,
+        );
+        logVerbose(`[infoflow] downloaded image from ${imageUrl}, saved to ${saved.path}`);
+        return { path: saved.path, contentType: saved.contentType ?? fetched.contentType };
+      }),
+    );
+    for (const result of results) {
+      if (result.status === "fulfilled") {
+        mediaList.push(result.value);
+      } else {
+        const reason = String(result.reason);
+        logVerbose(`[infoflow] failed to download image: ${reason}`);
+        failReasons.push(reason);
+      }
+    }
+  }
+
+  const mediaPayload = buildAgentMediaPayload(mediaList);
+
+  // If user sent images but some/all downloads failed, adjust the body to inform the LLM.
+  const requestedImageCount = event.imageUrls?.length ?? 0;
+  const downloadedImageCount = mediaList.length;
+  const failedImageCount = requestedImageCount - downloadedImageCount;
+  if (requestedImageCount > 0 && failedImageCount > 0) {
+    // Deduplicate error reasons and truncate for readability
+    const uniqueReasons = [...new Set(failReasons)];
+    const reasonSummary = uniqueReasons.map((r) => r.slice(0, 200)).join("; ");
+
+    if (downloadedImageCount === 0) {
+      // All failed
+      const failNote =
+        `[The user sent ${requestedImageCount > 1 ? `${requestedImageCount} images` : "an image"}, ` +
+        `but failed to load: ${reasonSummary}]`;
+      if (combinedBody.includes("<media:image>")) {
+        combinedBody = combinedBody.replace(/<media:image>(\s*\(\d+ images\))?/, failNote);
+      } else {
+        combinedBody += `\n\n${failNote}`;
+      }
+    } else {
+      // Partial failure: some images loaded, some didn't
+      const failNote = `[${failedImageCount} of ${requestedImageCount} images failed to load: ${reasonSummary}]`;
+      combinedBody += `\n\n${failNote}`;
+    }
+  }
+
   const ctxPayload = core.channel.reply.finalizeInboundContext({
-    Body: body,
+    Body: combinedBody,
     RawBody: event.rawMes ?? mes,
     CommandBody: mes,
     From: fromAddress,
@@ -509,7 +657,9 @@ export async function handleInfoflowMessage(params: HandleInfoflowMessageParams)
     OriginatingTo: toAddress,
     WasMentioned: isGroup ? event.wasMentioned : undefined,
     ReplyToBody: event.replyContext ? event.replyContext.join("\n---\n") : undefined,
+    InboundHistory: inboundHistory,
     CommandAuthorized: true,
+    ...mediaPayload,
   });
 
   // Record session using recordInboundSession for proper session tracking
@@ -532,6 +682,14 @@ export async function handleInfoflowMessage(params: HandleInfoflowMessageParams)
 
     // "record" mode: save to session only, no think, no reply
     if (replyMode === "record") {
+      if (groupIdStr) {
+        recordPendingHistoryEntryIfEnabled({
+          historyMap: chatHistories,
+          historyKey: groupIdStr,
+          entry: { sender: senderName || fromuser, body: mes, timestamp: Date.now() },
+          limit: DEFAULT_GROUP_HISTORY_LIMIT,
+        });
+      }
       return;
     }
 
@@ -550,6 +708,14 @@ export async function handleInfoflowMessage(params: HandleInfoflowMessageParams)
         ) {
           ctxPayload.GroupSystemPrompt = buildFollowUpPrompt();
         } else {
+          if (groupIdStr) {
+            recordPendingHistoryEntryIfEnabled({
+              historyMap: chatHistories,
+              historyKey: groupIdStr,
+              entry: { sender: senderName || fromuser, body: mes, timestamp: Date.now() },
+              limit: DEFAULT_GROUP_HISTORY_LIMIT,
+            });
+          }
           return;
         }
       }
@@ -575,6 +741,14 @@ export async function handleInfoflowMessage(params: HandleInfoflowMessageParams)
           // Follow-up window: let LLM decide if this is a follow-up
           ctxPayload.GroupSystemPrompt = buildFollowUpPrompt();
         } else {
+          if (groupIdStr) {
+            recordPendingHistoryEntryIfEnabled({
+              historyMap: chatHistories,
+              historyKey: groupIdStr,
+              entry: { sender: senderName || fromuser, body: mes, timestamp: Date.now() },
+              limit: DEFAULT_GROUP_HISTORY_LIMIT,
+            });
+          }
           return;
         }
       }
@@ -632,22 +806,36 @@ export async function handleInfoflowMessage(params: HandleInfoflowMessageParams)
     atOptions: isGroup && event.wasMentioned ? { atUserIds: [fromuser] } : undefined,
     // Pass mention IDs for LLM-driven @mention resolution in outbound text
     mentionIds: isGroup ? event.mentionIds : undefined,
+    // Pass inbound messageId for outbound reply-to (group only)
+    replyToMessageId: isGroup ? event.messageId : undefined,
+    replyToPreview: isGroup ? mes : undefined,
   });
 
-  await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+  const dispatchResult = await core.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
     ctx: ctxPayload,
     cfg,
     dispatcherOptions,
     replyOptions,
   });
 
+  const didReply = dispatchResult?.queuedFinal ?? false;
+
+  // Clear accumulated history after dispatch (it's now in the session transcript)
+  if (isGroup && historyKey) {
+    clearHistoryEntriesIfEnabled({
+      historyMap: chatHistories,
+      historyKey,
+      limit: DEFAULT_GROUP_HISTORY_LIMIT,
+    });
+  }
+
   // Record bot reply timestamp for follow-up window tracking
-  if (isGroup && groupId !== undefined) {
+  if (didReply && isGroup && groupId !== undefined) {
     recordGroupReply(String(groupId));
   }
 
   logVerbose(
-    `[infoflow] dispatch complete: ${chatType} from ${fromuser}, hasGroupSystemPrompt=${Boolean(ctxPayload.GroupSystemPrompt)}`,
+    `[infoflow] dispatch complete: ${chatType} from ${fromuser}, replied=${didReply}, finalCount=${dispatchResult?.counts.final ?? 0}, hasGroupSystemPrompt=${Boolean(ctxPayload.GroupSystemPrompt)}`,
   );
 }
 

package/src/channel.ts

@@ -17,11 +17,12 @@ import {
 } from "./accounts.js";
 import { infoflowMessageActions } from "./actions.js";
 import { logVerbose } from "./logging.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 { InfoflowMessageContentItem, ResolvedInfoflowAccount } from "./types.js";
+import type { ResolvedInfoflowAccount } from "./types.js";
 
 // Re-export types and account functions for external consumers
 export type { InfoflowAccountConfig, ResolvedInfoflowAccount } from "./types.js";
@@ -44,12 +45,14 @@ export const infoflowPlugin: ChannelPlugin<ResolvedInfoflowAccount> = {
   capabilities: {
     chatTypes: ["direct", "group"],
     nativeCommands: true,
+    unsend: true,
   },
   reload: { configPrefixes: ["channels.infoflow"] },
   actions: infoflowMessageActions,
   agentPrompt: {
     messageToolHints: () => [
       'Infoflow group @mentions: set atAll=true to @all members, or mentionUserIds="user1,user2" (comma-separated uuapName) to @mention specific users. Only effective for group targets (group:<id>).',
+      'Infoflow supports message recall (撤回): use action="delete" to recall the most recent message, or specify messageId to recall a specific message. Works for both private and group messages.',
     ],
   },
   config: {
@@ -221,39 +224,78 @@ export const infoflowPlugin: ChannelPlugin<ResolvedInfoflowAccount> = {
         messageId: result.ok ? (result.messageId ?? "sent") : "failed",
       };
     },
-    sendMedia: async ({ cfg, to, text, mediaUrl, accountId }) => {
+    sendMedia: async ({ cfg, to, text, mediaUrl, accountId, mediaLocalRoots }) => {
       logVerbose(`[infoflow:sendMedia] to=${to}, accountId=${accountId}, mediaUrl=${mediaUrl}`);
 
-      // Build contents array: text (if provided) + link for media URL
-      const contents: InfoflowMessageContentItem[] = [];
       const trimmedText = text?.trim();
+
+      // Helper: send text as markdown
+      const sendText = () =>
+        sendInfoflowMessage({
+          cfg,
+          to,
+          contents: [{ type: "markdown", content: trimmedText! }],
+          accountId: accountId ?? undefined,
+        });
+
+      // Helper: attempt native image send, fall back to link
+      const sendImage = async (): Promise<{ ok: boolean; messageId?: string }> => {
+        if (!mediaUrl) return { ok: false };
+        try {
+          const prepared = await prepareInfoflowImageBase64({
+            mediaUrl,
+            mediaLocalRoots: mediaLocalRoots ?? undefined,
+          });
+          if (prepared.isImage) {
+            const result = await sendInfoflowImageMessage({
+              cfg,
+              to,
+              base64Image: prepared.base64,
+              accountId: accountId ?? undefined,
+            });
+            if (result.ok) return { ok: true, messageId: result.messageId };
+            // Native send failed, fall back to link
+            logVerbose(
+              `[infoflow:sendMedia] native image failed: ${result.error}, falling back to link`,
+            );
+          }
+        } catch (err) {
+          logVerbose(`[infoflow:sendMedia] image prep failed, falling back to link: ${err}`);
+        }
+        // Fallback: send as link
+        const linkResult = await sendInfoflowMessage({
+          cfg,
+          to,
+          contents: [{ type: "link", content: mediaUrl }],
+          accountId: accountId ?? undefined,
+        });
+        return { ok: linkResult.ok, messageId: linkResult.messageId };
+      };
+
+      // Dispatch: concurrent text + image, or text-only, or image-only
+      if (trimmedText && mediaUrl) {
+        const [, imageResult] = await Promise.all([sendText(), sendImage()]);
+        return {
+          channel: "infoflow",
+          messageId: imageResult.ok ? (imageResult.messageId ?? "sent") : "failed",
+        };
+      }
       if (trimmedText) {
-        // 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.
-        contents.push({ type: "markdown", content: trimmedText });
+        const result = await sendText();
+        return {
+          channel: "infoflow",
+          messageId: result.ok ? (result.messageId ?? "sent") : "failed",
+        };
       }
       if (mediaUrl) {
-        contents.push({ type: "link", content: mediaUrl });
-      }
-
-      // Fallback: if no valid content, return early
-      if (contents.length === 0) {
+        const result = await sendImage();
         return {
           channel: "infoflow",
-          messageId: "failed",
+          messageId: result.ok ? (result.messageId ?? "sent") : "failed",
         };
       }
 
-      const result = await sendInfoflowMessage({
-        cfg,
-        to,
-        contents,
-        accountId: accountId ?? undefined,
-      });
-      return {
-        channel: "infoflow",
-        messageId: result.ok ? (result.messageId ?? "sent") : "failed",
-      };
+      return { channel: "infoflow", messageId: "failed" };
     },
   },
   status: {

package/src/infoflow-req-parse.ts

@@ -61,9 +61,9 @@ function isDuplicateMessage(msgData: Record<string, unknown>): boolean {
  * Called after successfully sending a message to prevent
  * the bot from processing its own outbound messages as inbound.
  */
-export function recordSentMessageId(messageId: string | number): void {
+export function recordSentMessageId(messageId: string | null): void {
   if (messageId == null) return;
-  messageCache.check(String(messageId)); // Will record if not duplicate
+  messageCache.check(messageId);
 }
 
 // ---------------------------------------------------------------------------
@@ -334,7 +334,6 @@ function tryDecryptAndDispatch(params: DecryptDispatchParams): ParseResult {
         );
       });
 
-      logVerbose(`[infoflow] ${chatType}: message dispatched successfully`);
       return { handled: true, statusCode: 200, body: "success" };
     }
   }