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

package/src/channel/outbound.ts

@@ -4,18 +4,23 @@
  */
 
 import { randomUUID } from "node:crypto";
-import type { OpenClawConfig } from "openclaw/plugin-sdk";
-import { resolveInfoflowAccount } from "./accounts.js";
+import type { OpenClawConfig } from "openclaw/plugin-sdk/plugin-entry";
 import { recordSentMessageId } from "../adapter/inbound/webhook-parser.js";
-import { getInfoflowSendLog, formatInfoflowError, logVerbose } from "../logging.js";
-import { getOrCreateAdapter, _resetAdapters } from "../utils/token-adapter.js";
 import { coreEvents } from "../events.js";
+import { getInfoflowSendLog, formatInfoflowError, logVerbose } from "../logging.js";
 import type {
+  InfoflowGroupAgentInfo,
   InfoflowGroupMessageBodyItem,
   InfoflowMessageContentItem,
   InfoflowOutboundReply,
   ResolvedInfoflowAccount,
 } from "../types.js";
+import {
+  registerGroupMemberListFetcher,
+  replaceAgentNameMentions,
+} from "../utils/group-agent-cache.js";
+import { getOrCreateAdapter, _resetAdapters } from "../utils/token-adapter.js";
+import { resolveInfoflowAccount } from "./accounts.js";
 
 export const DEFAULT_TIMEOUT_MS = 30_000; // 30 seconds
 
@@ -39,6 +44,8 @@ export const INFOFLOW_PRIVATE_SEND_PATH = "/api/v1/app/message/send";
 export const INFOFLOW_GROUP_SEND_PATH = "/api/v1/robot/msg/groupmsgsend";
 export const INFOFLOW_GROUP_RECALL_PATH = "/api/v1/robot/group/msgRecall";
 export const INFOFLOW_PRIVATE_RECALL_PATH = "/api/v1/app/message/revoke";
+export const INFOFLOW_ASR_QUERY_PATH = "/api/v1/va/queryASRResult";
+export const INFOFLOW_GROUP_MEMBER_LIST_PATH = "/api/v1/robot/group/memberList";
 
 // ---------------------------------------------------------------------------
 // Helper Functions
@@ -148,6 +155,60 @@ export function extractMsgSeqId(data: Record<string, unknown>): string | undefin
   return undefined;
 }
 
+function buildGroupAtDisplayPrefix(items: InfoflowGroupMessageBodyItem[]): string | undefined {
+  const parts: string[] = [];
+  for (const item of items) {
+    if (item.type !== "AT") {
+      continue;
+    }
+    if (item.atall) {
+      parts.push("@all");
+      continue;
+    }
+    for (const userId of item.atuserids ?? []) {
+      const normalized = userId.trim();
+      if (normalized) {
+        parts.push(`@${normalized}`);
+      }
+    }
+    for (const agentId of item.atagentids ?? []) {
+      parts.push(`@${agentId}`);
+    }
+  }
+  return parts.length > 0 ? parts.join(" ") : undefined;
+}
+
+function applyGroupAtDisplayPrefix(
+  items: InfoflowGroupMessageBodyItem[],
+): InfoflowGroupMessageBodyItem[] {
+  const prefix = buildGroupAtDisplayPrefix(items);
+  if (!prefix) {
+    return items;
+  }
+
+  const next = [...items];
+  const textIndex = next.findIndex((item) => item.type === "MD");
+  if (textIndex < 0) {
+    return next;
+  }
+
+  const item = next[textIndex];
+  if (item.type !== "MD") {
+    return next;
+  }
+
+  const content = item.content ?? "";
+  if (content.trimStart().startsWith(prefix)) {
+    return next;
+  }
+
+  next[textIndex] = {
+    ...item,
+    content: content.trim().length > 0 ? `${prefix} ${content}` : prefix,
+  };
+  return next;
+}
+
 // ---------------------------------------------------------------------------
 // Token Management
 // ---------------------------------------------------------------------------
@@ -164,6 +225,9 @@ export async function getAppAccessToken(params: {
   timeoutMs?: number;
 }): Promise<{ ok: boolean; token?: string; error?: string }> {
   try {
+    getInfoflowSendLog().info(
+      `[token] getAppAccessToken: apiHost=${params.apiHost}, appKey=${params.appKey.slice(0, 4)}***`,
+    );
     const adapter = getOrCreateAdapter({
       apiHost: params.apiHost,
       appKey: params.appKey,
@@ -172,7 +236,11 @@ export async function getAppAccessToken(params: {
     const token = await adapter.getToken();
     return { ok: true, token };
   } catch (err) {
-    return { ok: false, error: formatInfoflowError(err) };
+    const error = formatInfoflowError(err);
+    getInfoflowSendLog().error(
+      `[token] getAppAccessToken failed: apiHost=${params.apiHost}, appKey=${params.appKey.slice(0, 4)}***, error=${error}`,
+    );
+    return { ok: false, error };
   }
 }
 
@@ -190,9 +258,10 @@ export async function sendInfoflowPrivateMessage(params: {
   account: ResolvedInfoflowAccount;
   toUser: string;
   contents: InfoflowMessageContentItem[];
+  replyTo?: InfoflowOutboundReply;
   timeoutMs?: number;
 }): Promise<{ ok: boolean; error?: string; invaliduser?: string; msgkey?: string }> {
-  const { account, toUser, contents, timeoutMs = DEFAULT_TIMEOUT_MS } = params;
+  const { account, toUser, contents, replyTo, timeoutMs = DEFAULT_TIMEOUT_MS } = params;
   const { apiHost, appKey, appSecret } = account.config;
 
   // Validate account config
@@ -275,6 +344,23 @@ export async function sendInfoflowPrivateMessage(params: {
       }
     }
 
+    // Inject reply fields for private message quote/reply
+    // API format: reply is an array of { content, uid, msgid, msgid2 }
+    if (replyTo && payload.msgtype !== "md") {
+      payload.reply = [
+        {
+          content: replyTo.preview ?? "",
+          uid: replyTo.imid ?? "0",
+          msgid: String(replyTo.messageid),
+          ...(replyTo.msgid2 ? { msgid2: replyTo.msgid2 } : {}),
+        },
+      ];
+      // Include agentid if available
+      if (account.config.appAgentId != null) {
+        payload.agentid = String(account.config.appAgentId);
+      }
+    }
+
     const headers = {
       Authorization: `Bearer-${tokenResult.token}`,
       "Content-Type": "application/json; charset=utf-8",
@@ -283,8 +369,11 @@ export async function sendInfoflowPrivateMessage(params: {
 
     const bodyStr = JSON.stringify(payload);
 
-    // Log request URL and body when verbose logging is enabled
-    logVerbose(`[infoflow:sendPrivate] POST body: ${bodyStr}`);
+    // Log request
+    getInfoflowSendLog().info(
+      `[outbound:dm] to=${toUser}, msgtype=${payload.msgtype}, bodyLen=${bodyStr.length}, hasReply=${!!replyTo}`,
+    );
+    logVerbose(`[outbound:dm] POST body: ${bodyStr}`);
 
     const res = await fetch(`${ensureHttps(apiHost)}${INFOFLOW_PRIVATE_SEND_PATH}`, {
       method: "POST",
@@ -294,8 +383,16 @@ export async function sendInfoflowPrivateMessage(params: {
     });
 
     const responseText = await res.text();
+    if (!res.ok) {
+      getInfoflowSendLog().error(
+        `[outbound:dm] HTTP error: status=${res.status}, body=${responseText.slice(0, 200)}`,
+      );
+    }
     const data = JSON.parse(responseText) as Record<string, unknown>;
-    logVerbose(`[infoflow:sendPrivate] response: status=${res.status}, data=${responseText}`);
+    getInfoflowSendLog().info(
+      `[outbound:dm] response: status=${res.status}, code=${data.code ?? "?"}, msgkey=${(data.data as any)?.msgkey ?? "?"}`,
+    );
+    logVerbose(`[outbound:dm] response body: ${responseText}`);
 
     // Check outer code first
     const code = typeof data.code === "string" ? data.code : "";
@@ -328,7 +425,10 @@ export async function sendInfoflowPrivateMessage(params: {
       coreEvents.emit("message:sent", {
         accountId: account.accountId,
         target: toUser,
-        from: account.config.appAgentId != null ? `agent:${account.config.appAgentId}` : "agent:unknown",
+        from:
+          account.config.appAgentId != null
+            ? `agent:${account.config.appAgentId}`
+            : "agent:unknown",
         messageid: msgkey,
         msgseqid: "",
         contents,
@@ -389,7 +489,7 @@ export async function sendInfoflowGroupMessage(params: {
     } else if (type === "at") {
       // Parse AT content: "all" means atall, otherwise comma-separated user IDs
       if (item.content === "all") {
-        body.push({ type: "AT", atall: true, atuserids: [] });
+        body.push({ type: "AT", atall: true });
       } else {
         const userIds = item.content
           .split(",")
@@ -412,7 +512,7 @@ export async function sendInfoflowGroupMessage(params: {
         .map((s) => Number(s.trim()))
         .filter(Number.isFinite);
       if (agentIds.length > 0) {
-        body.push({ type: "AT", atuserids: [], atagentids: agentIds });
+        body.push({ type: "AT", atagentids: agentIds });
       }
     } else if (type === "image") {
       body.push({ type: "IMAGE", content: item.content });
@@ -422,7 +522,9 @@ export async function sendInfoflowGroupMessage(params: {
   // Split body: LINK and IMAGE must be sent as individual messages
   const linkItems = body.filter((b) => b.type === "LINK");
   const imageItems = body.filter((b) => b.type === "IMAGE");
-  const textItems = body.filter((b) => b.type !== "LINK" && b.type !== "IMAGE");
+  const textItems = applyGroupAtDisplayPrefix(
+    body.filter((b) => b.type !== "LINK" && b.type !== "IMAGE"),
+  );
 
   // Get token first (shared by all sends)
   const tokenResult = await getAppAccessToken({ apiHost, appKey, appSecret, timeoutMs });
@@ -465,10 +567,10 @@ export async function sendInfoflowGroupMessage(params: {
           ...(replyTo
             ? {
                 reply: {
-                  messageid: String(replyTo.messageid),  // messageid应该是字符串
+                  messageid: String(replyTo.messageid),
                   preview: replyTo.preview ?? "",
-                  ...(replyTo.imid ? { imid: replyTo.imid } : {}),  // 如果有 imid 则添加
-                  replyType: replyTo.replytype ?? "1",   // 注意是replyType,不是replytype
+                  ...(replyTo.imid ? { imid: replyTo.imid } : {}),
+                  replytype: replyTo.replytype ?? "1",
                 },
               }
             : {}),
@@ -478,6 +580,11 @@ export async function sendInfoflowGroupMessage(params: {
       // Build request body
       const bodyStr = JSON.stringify(payload);
 
+      getInfoflowSendLog().info(
+        `[outbound:group] groupId=${groupId}, msgtype=${msgtype}, bodyLen=${bodyStr.length}, hasReply=${!!replyTo}`,
+      );
+      logVerbose(`[outbound:group] POST body: ${bodyStr}`);
+
       const res = await fetch(`${ensureHttps(apiHost)}${INFOFLOW_GROUP_SEND_PATH}`, {
         method: "POST",
         headers,
@@ -486,8 +593,16 @@ export async function sendInfoflowGroupMessage(params: {
       });
 
       const responseText = await res.text();
+      if (!res.ok) {
+        getInfoflowSendLog().error(
+          `[outbound:group] HTTP error: status=${res.status}, body=${responseText.slice(0, 200)}`,
+        );
+      }
       const data = JSON.parse(responseText) as Record<string, unknown>;
-      logVerbose(`[infoflow:sendGroup] response: status=${res.status}, data=${responseText}`);
+      getInfoflowSendLog().info(
+        `[outbound:group] response: status=${res.status}, code=${data.code ?? "?"}, messageid=${extractIdFromRawJson(responseText, "messageid") ?? "?"}`,
+      );
+      logVerbose(`[outbound:group] response body: ${responseText}`);
 
       const code = typeof data.code === "string" ? data.code : "";
       if (code !== "ok") {
@@ -532,7 +647,8 @@ export async function sendInfoflowGroupMessage(params: {
     coreEvents.emit("message:sent", {
       accountId: account.accountId,
       target: `group:${groupId}`,
-      from: account.config.appAgentId != null ? `agent:${account.config.appAgentId}` : "agent:unknown",
+      from:
+        account.config.appAgentId != null ? `agent:${account.config.appAgentId}` : "agent:unknown",
       messageid: result.messageid,
       msgseqid: result.msgseqid ?? "",
       contents: digestContents,
@@ -805,7 +921,10 @@ async function resolveLocalImageLinks(
 
     // Attempt image detection for local path
     try {
-      const prepared = await prepareInfoflowImageBase64({ mediaUrl: href, mediaLocalRoots:[href] });
+      const prepared = await prepareInfoflowImageBase64({
+        mediaUrl: href,
+        mediaLocalRoots: [href],
+      });
       if (prepared.isImage) {
         resolved.push({ type: "image", content: prepared.base64 });
         continue;
@@ -861,15 +980,90 @@ export async function sendInfoflowMessage(params: {
   // Parse target: remove "infoflow:" prefix if present
   const target = to.replace(/^infoflow:/i, "");
 
+  getInfoflowSendLog().info(
+    `[outbound] sendMessage: to=${target}, items=${resolvedContents.length}, types=[${resolvedContents.map((c) => c.type).join(",")}]`,
+  );
+
   // Check if target is a group (format: group:123)
   const groupMatch = target.match(/^group:(\d+)/i);
   if (groupMatch) {
-    // Group path: sendInfoflowGroupMessage already handles IMAGE items
     const groupId = Number(groupMatch[1]);
+
+    // Resolve @robotName → @agentId in text/md content items using the group member cache.
+    // Also collect resolved agentIds to create at-agent content items.
+    // Quick skip: only scan if any text/md item contains '@'
+    const finalContents = [...resolvedContents];
+    const resolvedAgentIds: number[] = [];
+    const hasAtMention = finalContents.some((item) => {
+      const t = item.type.toLowerCase();
+      return (t === "text" || t === "md" || t === "markdown") && item.content.includes("@");
+    });
+    if (hasAtMention) {
+      for (let i = 0; i < finalContents.length; i++) {
+        const item = finalContents[i];
+        const t = item.type.toLowerCase();
+        if (t === "text" || t === "md" || t === "markdown") {
+          try {
+            const replaced = await replaceAgentNameMentions({
+              text: item.content,
+              account,
+              groupId,
+            });
+            if (replaced.text !== item.content) {
+              finalContents[i] = { ...item, content: replaced.text };
+              for (const id of replaced.newAgentIds) {
+                if (!resolvedAgentIds.includes(id)) {
+                  resolvedAgentIds.push(id);
+                }
+              }
+            }
+          } catch {
+            // Non-fatal: continue with original text
+          }
+        }
+      }
+    }
+    // Strip pure numeric IDs from type: "at" content items — they are not valid
+    // uuapNames (likely robot imids placed by LLM via mentionUserIds). Robot @mentions
+    // are handled by replaceAgentNameMentions resolving @name → at-agent with correct agentId.
+    for (let i = finalContents.length - 1; i >= 0; i--) {
+      const item = finalContents[i];
+      if (item.type !== "at" || item.content === "all") continue;
+
+      const ids = item.content
+        .split(",")
+        .map((s) => s.trim())
+        .filter(Boolean);
+      const userIds = ids.filter((id) => !/^\d+$/.test(id));
+
+      if (userIds.length > 0) {
+        finalContents[i] = { ...item, content: userIds.join(",") };
+      } else {
+        finalContents.splice(i, 1);
+      }
+    }
+
+    // Add at-agent content item for resolved robot agentIds
+    if (resolvedAgentIds.length > 0) {
+      finalContents.unshift({ type: "at-agent", content: resolvedAgentIds.join(",") });
+    }
+
+    // Strip bodyForAgent annotations like "(robotid:4105000875)" from outbound text
+    for (let i = 0; i < finalContents.length; i++) {
+      const item = finalContents[i];
+      const t = item.type.toLowerCase();
+      if (t === "text" || t === "md" || t === "markdown") {
+        const cleaned = item.content.replace(/\s*\(robotid:\d+\)/g, "");
+        if (cleaned !== item.content) {
+          finalContents[i] = { ...item, content: cleaned };
+        }
+      }
+    }
+
     const result = await sendInfoflowGroupMessage({
       account,
       groupId,
-      contents: resolvedContents,
+      contents: finalContents,
       replyTo: params.replyTo,
     });
     return {
@@ -893,6 +1087,7 @@ export async function sendInfoflowMessage(params: {
       account,
       toUser: target,
       contents: nonImageContents,
+      replyTo: params.replyTo,
     });
     if (result.ok) {
       lastMessageId = result.msgkey;
@@ -924,6 +1119,148 @@ export async function sendInfoflowMessage(params: {
   return { ok: true, messageId: lastMessageId };
 }
 
+// ---------------------------------------------------------------------------
+// Voice ASR Query (语音识别)
+// ---------------------------------------------------------------------------
+
+/**
+ * Queries the Infoflow ASR (Automatic Speech Recognition) service
+ * to convert a voice message's audio into text.
+ *
+ * @param account - Resolved Infoflow account with config (for token)
+ * @param md5 - MD5 hash from the VoiceUrl fileid parameter
+ * @returns ASR text content, or undefined if recognition failed
+ */
+export async function queryASRResult(params: {
+  account: ResolvedInfoflowAccount;
+  md5: string;
+  timeoutMs?: number;
+}): Promise<{ ok: boolean; content?: string; error?: string }> {
+  const { account, md5, timeoutMs = DEFAULT_TIMEOUT_MS } = params;
+  const { apiHost, appKey, appSecret } = account.config;
+
+  const tokenResult = await getAppAccessToken({ apiHost, appKey, appSecret, timeoutMs });
+  if (!tokenResult.ok || !tokenResult.token) {
+    getInfoflowSendLog().error(`[infoflow:asr] token error: ${tokenResult.error}`);
+    return { ok: false, error: tokenResult.error ?? "failed to get token" };
+  }
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const controller = new AbortController();
+    timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+    const res = await fetch(`${ensureHttps(apiHost)}${INFOFLOW_ASR_QUERY_PATH}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer-${tokenResult.token}`,
+        "Content-Type": "application/x-www-form-urlencoded",
+      },
+      body: `md5=${encodeURIComponent(md5)}`,
+      signal: controller.signal,
+    });
+
+    const responseText = await res.text();
+    const data = JSON.parse(responseText) as Record<string, unknown>;
+    getInfoflowSendLog().info(
+      `[infoflow:asr] response: status=${res.status}, data=${responseText}`,
+    );
+
+    const code = typeof data.code === "string" ? data.code : "";
+    if (code !== "ok") {
+      const msg = String(data.message ?? data.msg ?? "");
+      const errMsg = msg ? `code=${code}, ${msg}` : `code=${code || "unknown"}`;
+      getInfoflowSendLog().error(`[infoflow:asr] failed: ${errMsg}`);
+      return { ok: false, error: errMsg };
+    }
+
+    const innerData = data.data as Record<string, unknown> | undefined;
+    const innerCode = innerData?.code;
+    if (innerCode !== 200) {
+      const errMsg = `ASR code=${innerCode}`;
+      getInfoflowSendLog().error(`[infoflow:asr] recognition failed: ${errMsg}`);
+      return { ok: false, error: errMsg };
+    }
+
+    const content = String(innerData?.content ?? "").trim();
+    return { ok: true, content: content || undefined };
+  } catch (err) {
+    const errMsg = formatInfoflowError(err);
+    getInfoflowSendLog().error(`[infoflow:asr] exception: ${errMsg}`);
+    return { ok: false, error: errMsg };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+/**
+ * Fetches the group member list to get robot name→agentId mappings.
+ */
+export async function fetchGroupMemberList(params: {
+  account: ResolvedInfoflowAccount;
+  groupId: number;
+  timeoutMs?: number;
+}): Promise<{ ok: boolean; agents?: InfoflowGroupAgentInfo[]; error?: string }> {
+  const { account, groupId, timeoutMs = DEFAULT_TIMEOUT_MS } = params;
+  const { apiHost, appKey, appSecret } = account.config;
+
+  const tokenResult = await getAppAccessToken({ apiHost, appKey, appSecret, timeoutMs });
+  if (!tokenResult.ok || !tokenResult.token) {
+    getInfoflowSendLog().error(`[infoflow:memberList] token error: ${tokenResult.error}`);
+    return { ok: false, error: tokenResult.error ?? "failed to get token" };
+  }
+
+  let timeout: ReturnType<typeof setTimeout> | undefined;
+  try {
+    const controller = new AbortController();
+    timeout = setTimeout(() => controller.abort(), timeoutMs);
+
+    const res = await fetch(`${ensureHttps(apiHost)}${INFOFLOW_GROUP_MEMBER_LIST_PATH}`, {
+      method: "POST",
+      headers: {
+        Authorization: `Bearer-${tokenResult.token}`,
+        "Content-Type": "application/json",
+      },
+      body: JSON.stringify({ groupId, recallType: 0 }),
+      signal: controller.signal,
+    });
+
+    const responseText = await res.text();
+    logVerbose(
+      `[infoflow:memberList] response: status=${res.status}, groupId=${groupId}, body=${responseText.slice(0, 500)}`,
+    );
+    const data = JSON.parse(responseText) as Record<string, unknown>;
+
+    // Response structure: { code: "ok", data: { errcode: 0, errmsg: "ok", data: { agentInfoList: [...] } } }
+    const code = typeof data.code === "string" ? data.code : "";
+    if (code !== "ok") {
+      getInfoflowSendLog().error(`[infoflow:memberList] failed: code=${code}`);
+      return { ok: false, error: `code=${code}` };
+    }
+
+    const outerData = data.data as Record<string, unknown> | undefined;
+    const errcode = outerData?.errcode as number | undefined;
+    if (errcode != null && errcode !== 0) {
+      const errmsg = String(outerData?.errmsg ?? `errcode=${errcode}`);
+      getInfoflowSendLog().error(`[infoflow:memberList] failed: ${errmsg}`);
+      return { ok: false, error: errmsg };
+    }
+
+    const innerData = outerData?.data as { agentInfoList?: InfoflowGroupAgentInfo[] } | undefined;
+    const agents = innerData?.agentInfoList ?? [];
+    return { ok: true, agents };
+  } catch (err) {
+    const errMsg = formatInfoflowError(err);
+    getInfoflowSendLog().error(`[infoflow:memberList] exception: ${errMsg}`);
+    return { ok: false, error: errMsg };
+  } finally {
+    clearTimeout(timeout);
+  }
+}
+
+// Wire up the group agent cache so it can call fetchGroupMemberList without circular imports
+registerGroupMemberListFetcher(fetchGroupMemberList);
+
 // ---------------------------------------------------------------------------
 // Test-only exports (@internal — not part of the public API)
 // ---------------------------------------------------------------------------