openclaw-plugin-yuanbao 2.14.0 → 2.15.0

package/dist/src/access/http/request.d.ts

@@ -44,6 +44,12 @@ export declare function getTokenStatus(accountId: string): {
     status: "valid" | "expired" | "refreshing" | "none";
     expiresAt: number | null;
 };
+export declare function computeSignature(params: {
+    nonce: string;
+    timestamp: string;
+    appKey: string;
+    appSecret: string;
+}): string;
 export declare function verifySignature(expected: string, actual: string): boolean;
 export declare function getSignToken(account: ResolvedYuanbaoAccount, log?: Log): Promise<SignTokenData>;
 export declare function forceRefreshSignToken(account: ResolvedYuanbaoAccount, log?: Log): Promise<SignTokenData>;

package/dist/src/access/http/request.js

@@ -46,7 +46,7 @@ export function getTokenStatus(accountId) {
         expiresAt: cached.expiresAt,
     };
 }
-function computeSignature(params) {
+export function computeSignature(params) {
     const plain = params.nonce + params.timestamp + params.appKey + params.appSecret;
     return createHmac("sha256", params.appSecret).update(plain).digest("hex");
 }

package/dist/src/access/ws/biz-codec.js

@@ -74,6 +74,7 @@ export function toProtoMsgBody(elements) {
                 url: c.url,
                 fileSize: c.file_size,
                 fileName: c.file_name,
+                extMap: c.ext_map,
             },
         };
     });
@@ -122,6 +123,9 @@ export function fromProtoMsgBody(elements) {
         if (mc?.fileName) {
             content.file_name = mc.fileName;
         }
+        if (mc?.extMap && Object.keys(mc.extMap).length > 0) {
+            content.ext_map = mc.extMap;
+        }
         return {
             msg_type: el.msgType || "",
             msg_content: content,

package/dist/src/access/ws/client.js

@@ -573,6 +573,7 @@ export class YuanbaoWsClient {
         this.lastHeartbeatAt = Date.now();
         this.sendBinary(binary);
         this.log.debug("heartbeat sent");
+        this.scheduleNextPingCheck();
     }
     onPingResponse(head, data) {
         this.heartbeatAckReceived = true;

package/dist/src/access/ws/proto/biz.json

@@ -97,6 +97,11 @@
                                                 "fileName": {
                                                     "type": "string",
                                                     "id": 12
+                                                },
+                                                "extMap": {
+                                                    "keyType": "string",
+                                                    "type": "string",
+                                                    "id": 999
                                                 }
                                             }
                                         },

package/dist/src/business/messaging/context.d.ts

@@ -7,6 +7,10 @@ import type { ResolvedYuanbaoAccount } from "../../types.js";
 /** Message processing context */
 export type MessageHandlerContext = {
     groupCode?: string;
+    /** User ID/account that sent the message; used for ext_map key matching. */
+    fromAccount?: string;
+    /** Display name of the message sender; used by forwarded-record parsing. */
+    senderNickname?: string;
     account: ResolvedYuanbaoAccount;
     config: OpenClawConfig;
     core: PluginRuntime;

package/dist/src/business/messaging/handlers/custom/forward-records-proto.d.ts

@@ -0,0 +1,8 @@
+/**
+ * Protobuf decoder for WeChat forwarded chat-record payloads.
+ *
+ * The server stores `ForwardMsgData` in `MsgContent.ext_map` as a base64
+ * string whose decoded bytes are protobuf wire data.
+ */
+import type { ForwardMsgData } from "./forward-records.js";
+export declare function decodeForwardMsgDataBase64(value: string): ForwardMsgData | undefined;

package/dist/src/business/messaging/handlers/custom/forward-records-proto.js

@@ -0,0 +1,103 @@
+/**
+ * Protobuf decoder for WeChat forwarded chat-record payloads.
+ *
+ * The server stores `ForwardMsgData` in `MsgContent.ext_map` as a base64
+ * string whose decoded bytes are protobuf wire data.
+ */
+import protobuf from "protobufjs";
+const FORWARD_PROTO_DESCRIPTOR = {
+    nested: {
+        ForwardMsgData: {
+            fields: {
+                sub_type: { type: "int32", id: 1 },
+                msg_begin_time: { type: "int64", id: 2 },
+                msg_end_time: { type: "int64", id: 3 },
+                nick_name: { type: "string", id: 4 },
+                msg: { rule: "repeated", type: "Msg", id: 5 },
+            },
+        },
+        Msg: {
+            fields: {
+                sender: { type: "string", id: 1 },
+                time: { type: "int64", id: 2 },
+                plainText: { type: "string", id: 3 },
+                msgContent: { rule: "repeated", type: "MsgContent", id: 4 },
+            },
+        },
+        MsgContent: {
+            fields: {
+                type: { type: "int32", id: 1 },
+                text: { type: "string", id: 2 },
+                multimedia: { rule: "repeated", type: "Multimedia", id: 3 },
+            },
+        },
+        Multimedia: {
+            fields: {
+                type: { type: "string", id: 1 },
+                url: { type: "string", id: 2 },
+                origin_url: { type: "string", id: 3 },
+                file_name: { type: "string", id: 4 },
+                size: { type: "int64", id: 5 },
+                width: { type: "int32", id: 6 },
+                height: { type: "int32", id: 7 },
+                style: { type: "string", id: 8 },
+                pendants: { rule: "repeated", type: "string", id: 9 },
+                created_time: { type: "int64", id: 10 },
+                index_url: { type: "string", id: 11 },
+                cover_url: { type: "string", id: 12 },
+                duration: { type: "int64", id: 13 },
+                guide_id: { type: "int32", id: 14 },
+                media_id: { type: "string", id: 15 },
+                extract: { type: "bool", id: 16 },
+                title: { type: "string", id: 17 },
+                content: { type: "string", id: 18 },
+                session_id: { type: "string", id: 19 },
+                question_id: { type: "string", id: 20 },
+                goods_trace_id: { type: "string", id: 21 },
+                cache_key: { type: "string", id: 22 },
+                chat_record_id: { type: "string", id: 23 },
+                doc_type: { type: "string", id: 24 },
+                image_base64: { type: "string", id: 25 },
+                parse_file_type: { type: "string", id: 26 },
+                parse_file_url: { type: "string", id: 27 },
+                sensitive: { type: "bool", id: 28 },
+                extra: { type: "string", id: 29 },
+                icon_url: { type: "string", id: 30 },
+                source: { type: "string", id: 31 },
+                app_id: { type: "string", id: 32 },
+                link_url: { type: "string", id: 33 },
+                msg_count: { type: "int32", id: 34 },
+                msg_time: { type: "int64", id: 35 },
+                forward_msg_id: { type: "string", id: 36 },
+            },
+        },
+    },
+};
+let forwardMsgDataType;
+function getForwardMsgDataType() {
+    if (!forwardMsgDataType) {
+        forwardMsgDataType = protobuf.Root.fromJSON(FORWARD_PROTO_DESCRIPTOR).lookupType("ForwardMsgData");
+    }
+    return forwardMsgDataType;
+}
+export function decodeForwardMsgDataBase64(value) {
+    try {
+        const bytes = Buffer.from(value, "base64");
+        if (bytes.length === 0) {
+            return undefined;
+        }
+        const type = getForwardMsgDataType();
+        const decoded = type.decode(bytes);
+        const object = type.toObject(decoded, {
+            longs: String,
+            enums: Number,
+            bytes: String,
+            arrays: true,
+            objects: true,
+        });
+        return object && typeof object === "object" ? object : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}

package/dist/src/business/messaging/handlers/custom/forward-records.d.ts

@@ -0,0 +1,63 @@
+/**
+ * WeChat forwarded chat-record (elem_type 1009) parsing.
+ *
+ * A forwarded chat record carries a truncated summary in `msg_content.data.text`
+ * and the full structured detail in `msg_content.ext_map` (protobuf field 999).
+ * The ext_map value is a base64-encoded protobuf `ForwardMsgData`.
+ *
+ * This module turns that detail into readable chat-record lines and appends
+ * contained images/files to the shared `medias` list so the existing download
+ * pipeline fetches them — matching how imageHandler / fileHandler already behave.
+ */
+import type { ExtractTextFromMsgBodyResult } from "../types.js";
+/** Multimedia entry inside a forwarded message content. */
+export interface ForwardMultimedia {
+    type?: string;
+    url?: string;
+    origin_url?: string;
+    parse_file_url?: string;
+    link_url?: string;
+    file_name?: string;
+    media_id?: string;
+    doc_type?: string;
+    title?: string;
+    [key: string]: unknown;
+}
+/** One content fragment of a forwarded message. */
+export interface ForwardMsgContent {
+    type?: number;
+    text?: string;
+    multimedia?: ForwardMultimedia[];
+}
+/** One message inside a forwarded chat record. */
+export interface ForwardMsg {
+    sender?: string;
+    time?: number | string;
+    plainText?: string;
+    msgContent?: ForwardMsgContent[];
+}
+/** Parsed `ForwardMsgData` (ext_map value). */
+export interface ForwardMsgData {
+    sub_type?: number;
+    msg_begin_time?: number | string;
+    msg_end_time?: number | string;
+    nick_name?: string;
+    msg?: ForwardMsg[];
+}
+/**
+ * Extract the `ForwardMsgData` from a `msg_content.ext_map`.
+ *
+ * Matching strategy (per spec): prefer a `wexin_forward_msg_*` key that ends
+ * with `_{userId}`; otherwise fall back to the first entry that parses into a
+ * WeChat chat record (`sub_type === 1`). Returns undefined when none matches.
+ */
+export declare function parseForwardMsgData(extMap: Record<string, unknown> | undefined, userId?: string): ForwardMsgData | undefined;
+/**
+ * Build a structured text block from a forwarded chat record and append any
+ * contained images/files to `resData.medias` (and link URLs to
+ * `resData.linkUrls`) for the downstream download / link-understanding steps.
+ *
+ * @param senderNickname display name of the user who forwarded the record.
+ * @returns the structured text, or undefined when the record has no messages.
+ */
+export declare function buildForwardRecordsText(data: ForwardMsgData, resData: ExtractTextFromMsgBodyResult, senderNickname?: string): string | undefined;

package/dist/src/business/messaging/handlers/custom/forward-records.js

@@ -0,0 +1,169 @@
+/**
+ * WeChat forwarded chat-record (elem_type 1009) parsing.
+ *
+ * A forwarded chat record carries a truncated summary in `msg_content.data.text`
+ * and the full structured detail in `msg_content.ext_map` (protobuf field 999).
+ * The ext_map value is a base64-encoded protobuf `ForwardMsgData`.
+ *
+ * This module turns that detail into readable chat-record lines and appends
+ * contained images/files to the shared `medias` list so the existing download
+ * pipeline fetches them — matching how imageHandler / fileHandler already behave.
+ */
+import { sanitizeMediaFilename } from "../../../utils/media.js";
+import { decodeForwardMsgDataBase64 } from "./forward-records-proto.js";
+/** EnumMsgContentType inside a forwarded record. */
+var ForwardContentType;
+(function (ForwardContentType) {
+    ForwardContentType[ForwardContentType["Text"] = 1] = "Text";
+    ForwardContentType[ForwardContentType["Multimedia"] = 2] = "Multimedia";
+    ForwardContentType[ForwardContentType["ForwardMsg"] = 3] = "ForwardMsg";
+})(ForwardContentType || (ForwardContentType = {}));
+/** ext_map key prefix for WeChat forwarded chat records. */
+const FORWARD_KEY_PREFIX = "wexin_forward_msg_";
+/** Cap the number of records folded into a prompt to keep it bounded. */
+const MAX_RECORDS = 100;
+const HEADER_RECORDS = "以下为用户的聊天记录";
+/**
+ * Extract the `ForwardMsgData` from a `msg_content.ext_map`.
+ *
+ * Matching strategy (per spec): prefer a `wexin_forward_msg_*` key that ends
+ * with `_{userId}`; otherwise fall back to the first entry that parses into a
+ * WeChat chat record (`sub_type === 1`). Returns undefined when none matches.
+ */
+export function parseForwardMsgData(extMap, userId) {
+    if (!extMap || typeof extMap !== "object") {
+        return undefined;
+    }
+    const entries = Object.entries(extMap).filter(([key]) => key.startsWith(FORWARD_KEY_PREFIX));
+    if (entries.length === 0) {
+        return undefined;
+    }
+    // Prefer a key whose suffix matches the current user; otherwise keep order.
+    const ordered = userId
+        ? [...entries].sort(([a], [b]) => {
+            const am = a.endsWith(`_${userId}`) ? 0 : 1;
+            const bm = b.endsWith(`_${userId}`) ? 0 : 1;
+            return am - bm;
+        })
+        : entries;
+    for (const [, value] of ordered) {
+        const data = coerceForwardData(value);
+        if (data && Number(data.sub_type) === 1) {
+            return data;
+        }
+    }
+    return undefined;
+}
+function coerceForwardData(value) {
+    if (typeof value === "string") {
+        return decodeForwardMsgDataBase64(value);
+    }
+    return undefined;
+}
+/**
+ * Build a structured text block from a forwarded chat record and append any
+ * contained images/files to `resData.medias` (and link URLs to
+ * `resData.linkUrls`) for the downstream download / link-understanding steps.
+ *
+ * @param senderNickname display name of the user who forwarded the record.
+ * @returns the structured text, or undefined when the record has no messages.
+ */
+export function buildForwardRecordsText(data, resData, senderNickname) {
+    const msgList = Array.isArray(data.msg) ? data.msg.slice(0, MAX_RECORDS) : [];
+    if (msgList.length === 0) {
+        return undefined;
+    }
+    const lines = [];
+    if (senderNickname) {
+        lines.push(`当前用户的昵称为${senderNickname}`);
+    }
+    lines.push(HEADER_RECORDS);
+    for (const msg of msgList) {
+        const sender = msg.sender ?? "";
+        const parts = buildMessageParts(msg, resData);
+        const body = parts.length > 0 ? parts.join("  ") : (msg.plainText ?? "");
+        lines.push(`${sender}：${body}`);
+    }
+    return lines.join("\n");
+}
+function buildMessageParts(msg, resData) {
+    const contents = Array.isArray(msg.msgContent) ? msg.msgContent : [];
+    if (contents.length === 0) {
+        return [];
+    }
+    const parts = [];
+    for (const content of contents) {
+        switch (content.type) {
+            case ForwardContentType.Text:
+                if (content.text) {
+                    parts.push(content.text);
+                }
+                break;
+            case ForwardContentType.Multimedia:
+                for (const media of content.multimedia ?? []) {
+                    const part = appendMedia(media, resData);
+                    if (part) {
+                        parts.push(part);
+                    }
+                }
+                break;
+            case ForwardContentType.ForwardMsg:
+                parts.push("[嵌套聊天记录]");
+                break;
+            default:
+                if (msg.plainText) {
+                    parts.push(msg.plainText);
+                }
+                break;
+        }
+    }
+    return parts;
+}
+/**
+ * Resolve a single multimedia item to a text placeholder and, for downloadable
+ * media (image/file/code/video-as-file), push it to `resData.medias`. Link
+ * shares are recorded in `resData.linkUrls` for link understanding.
+ */
+function appendMedia(media, resData) {
+    const mediaType = (media.type || media.doc_type || "").toLowerCase();
+    const url = media.url || media.origin_url || media.parse_file_url || media.link_url || "";
+    switch (mediaType) {
+        case "image": {
+            if (!url) {
+                return `[image:${media.file_name || "image"}]`;
+            }
+            const count = resData.medias.filter(m => m.mediaType === "image").length + 1;
+            const mediaName = sanitizeMediaFilename(media.file_name || media.media_id, `image${count}`);
+            resData.medias.push({ mediaType: "image", url, mediaName });
+            return `[image:${mediaName}]`;
+        }
+        case "file":
+        case "code":
+        case "document": {
+            if (!url) {
+                return `[file:${media.file_name || "file"}]`;
+            }
+            const count = resData.medias.filter(m => m.mediaType === "file").length + 1;
+            const mediaName = sanitizeMediaFilename(media.file_name || media.media_id, `file${count}`);
+            resData.medias.push({ mediaType: "file", url, mediaName });
+            return `[file:${mediaName}]`;
+        }
+        case "url": {
+            if (url) {
+                resData.linkUrls.push(url);
+            }
+            return `[link] ${[media.title || media.file_name, url].filter(Boolean).join(" ")}`.trimEnd();
+        }
+        case "video": {
+            if (!url) {
+                return `[video] ${media.file_name || "video"}`;
+            }
+            const count = resData.medias.filter(m => m.mediaType === "file").length + 1;
+            const mediaName = sanitizeMediaFilename(media.file_name || media.media_id, `video${count}`);
+            resData.medias.push({ mediaType: "file", url, mediaName });
+            return `[video:${mediaName}]`;
+        }
+        default:
+            return `[${mediaType || "media"}] ${url || media.file_name || ""}`.trimEnd();
+    }
+}

package/dist/src/business/messaging/handlers/custom/index.js

@@ -5,6 +5,7 @@
  * supports constructing custom message body.
  */
 import { createLog } from "../../../../logger.js";
+import { buildForwardRecordsText, parseForwardMsgData } from "./forward-records.js";
 import { extractLinkCard, extractLinkCardUrls } from "./link-card.js";
 /**
  * Build @user TIMCustomElem message body element.
@@ -71,15 +72,39 @@ export const customHandler = {
                         }
                         return extractLinkCard(customContent);
                     }
+                    case 1009: {
+                        // WeChat forwarded chat record: detail lives in msg_content.ext_map.
+                        const extMap = elem.msg_content?.ext_map;
+                        const extEntries = extMap ? Object.entries(extMap) : [];
+                        const forwardData = parseForwardMsgData(extMap, ctx.fromAccount);
+                        const summary = typeof customContent?.text === "string" ? customContent.text : undefined;
+                        if (forwardData) {
+                            const text = buildForwardRecordsText(forwardData, resData, ctx.senderNickname);
+                            if (text) {
+                                log.info("forwarded chat record parsed", {
+                                    recordCount: forwardData.msg?.length ?? 0,
+                                    mediaCount: resData.medias.length,
+                                    linkCount: resData.linkUrls.length,
+                                });
+                                return text;
+                            }
+                        }
+                        // Fallback: use the truncated summary so the AI still gets context.
+                        log.warn("forwarded chat record parse failed", {
+                            hasExtMap: Boolean(extMap),
+                            extMapKeyCount: extEntries.length,
+                            extMapValueTypes: extEntries.map(([, value]) => typeof value),
+                            hasSummary: Boolean(summary),
+                        });
+                        return summary || "用户转发了一条聊天记录，但插件未收到详细内容";
+                    }
                     default:
                         return FALLBACK_TEXT;
                 }
             }
             catch {
                 // JSON parse failed, fall back to placeholder
-                log.debug("TIMCustomElem data JSON parse failed", {
-                    data: elem.msg_content?.data,
-                });
+                log.debug("TIMCustomElem data JSON parse failed");
             }
         }
         return FALLBACK_TEXT;

package/dist/src/business/messaging/handlers/types.d.ts

@@ -27,6 +27,8 @@ export type MsgBodyItemType = {
         url?: string;
         file_size?: number;
         file_name?: string;
+        /** Extension map, e.g. WeChat forwarded chat record detail for elem_type 1009. */
+        ext_map?: Record<string, string>;
         [key: string]: unknown;
     };
 };

package/dist/src/business/outbound/queue.d.ts

@@ -19,6 +19,7 @@ export interface QueueSessionOptions {
     maxChars?: number;
     chunkText?: (text: string, maxChars: number) => string[];
 }
+export declare function defaultChunkText(text: string, max: number): string[];
 export declare function createQueueSession(opts: QueueSessionOptions): QueueSession;
 declare function createMergeTextSession(opts: QueueSessionOptions): QueueSession;
 export { createMergeTextSession as createMergeTextSessionForTest };

package/dist/src/business/outbound/queue.js

@@ -1,7 +1,7 @@
 /** Outbound queue (MessageSender-based). */
 import { createLog } from "../../logger.js";
 import { mdFence, mdBlock, mdAtomic, mdTable } from "../utils/markdown.js";
-function defaultChunkText(text, max) {
+export function defaultChunkText(text, max) {
     if (text.length <= max) {
         return [text];
     }

package/dist/src/business/pipeline/middlewares/extract-content.js

@@ -15,15 +15,22 @@ export const extractContent = {
             // Direct message opened from group chat panel; carry group_code
             ctx.groupCode = raw.private_from_group_code;
         }
-        // Build minimal ctx compatible with extractTextFromMsgBody's MessageHandlerContext
-        // Note: MessageHandlerContext.log needs verbose method, but ModuleLog doesn't have it
+        // Build minimal ctx compatible with extractTextFromMsgBody's MessageHandlerContext.
+        // Pass the real logger through so element-level diagnostics are not swallowed.
         const minCtx = {
             account: ctx.account,
             config: ctx.config,
             core: ctx.core,
-            log: { info: () => { }, warn: () => { }, error: () => { }, verbose: () => { } },
+            log: {
+                info: ctx.log.info.bind(ctx.log),
+                warn: ctx.log.warn.bind(ctx.log),
+                error: ctx.log.error.bind(ctx.log),
+                verbose: ctx.log.debug.bind(ctx.log),
+            },
             wsClient: ctx.wsClient,
             groupCode: ctx.groupCode,
+            fromAccount: ctx.fromAccount,
+            senderNickname: ctx.senderNickname,
         };
         const { rawBody, isAtBot, medias, mentions, linkUrls } = extractTextFromMsgBody(minCtx, raw.msg_body);
         ctx.rawBody = rawBody;

package/dist/src/infra/reply-classify.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Pure classification of the reply-quote decision (off / all / first).
+ *
+ * Extracted from transport.shouldAttachReplyRef so the off → self → all → first
+ * ordering (the part most prone to cross-language drift) is a single source of
+ * truth shared by the production sender and the cross-language contract test
+ * (yuanbao-bot-spec POLICY-008). TTL bookkeeping for the "first" mode stays with
+ * each caller: production uses InMemoryTtlDb (wall-clock), the contract test
+ * models an injected clock.
+ */
+import type { YuanbaoReplyToMode } from "../types.js";
+/** "no" = never attach; "yes" = attach now; "first" = attach iff not a duplicate. */
+export type ReplyClassification = "no" | "yes" | "first";
+export declare function classifyReplyMode(params: {
+    mode: YuanbaoReplyToMode;
+    refMsgId?: string | null;
+    refFromAccount?: string | null;
+    botYuanbaoUid?: string | null;
+}): ReplyClassification;

package/dist/src/infra/reply-classify.js

@@ -0,0 +1,27 @@
+/**
+ * Pure classification of the reply-quote decision (off / all / first).
+ *
+ * Extracted from transport.shouldAttachReplyRef so the off → self → all → first
+ * ordering (the part most prone to cross-language drift) is a single source of
+ * truth shared by the production sender and the cross-language contract test
+ * (yuanbao-bot-spec POLICY-008). TTL bookkeeping for the "first" mode stays with
+ * each caller: production uses InMemoryTtlDb (wall-clock), the contract test
+ * models an injected clock.
+ */
+export function classifyReplyMode(params) {
+    const { mode, refMsgId, refFromAccount, botYuanbaoUid } = params;
+    if (!refMsgId) {
+        return "no";
+    }
+    if (mode === "off") {
+        return "no";
+    }
+    // Avoid self-quoting: the replied message was sent by the bot itself.
+    if (refFromAccount && botYuanbaoUid && refFromAccount === botYuanbaoUid) {
+        return "no";
+    }
+    if (mode === "all") {
+        return "yes";
+    }
+    return "first";
+}

package/dist/src/infra/transport.js

@@ -6,6 +6,7 @@
 import { createLog } from "../logger.js";
 import { getMember } from "./cache/member.js";
 import { InMemoryTtlDb } from "./cache/ttl-db.js";
+import { classifyReplyMode } from "./reply-classify.js";
 const firstReplyRefDb = new InMemoryTtlDb({
     ttlMs: 60 * 1000,
     maxKeys: 100,
@@ -15,21 +16,19 @@ const firstReplyRefDb = new InMemoryTtlDb({
  */
 async function shouldAttachReplyRef(params) {
     const { account, refMsgId, groupCode, refFromAccount } = params;
-    if (!refMsgId) {
-        return false;
-    }
     const mode = account.replyToMode;
-    if (mode === "off") {
-        return false;
+    // Resolve the bot's own uid only when a self-quote check can actually fire
+    // (refMsgId present, mode != off, and a sender is known) — keeps the network
+    // lookup off the early-return paths, matching the previous control flow.
+    let botYuanbaoUid = null;
+    if (refMsgId && mode !== "off" && refFromAccount) {
+        botYuanbaoUid = (await getMember(account.accountId).queryYuanbaoUserId(groupCode)) ?? null;
     }
-    // Avoid self-quoting: compare the sender of the replied message
-    if (refFromAccount) {
-        const yuanbaoUserId = await getMember(account.accountId).queryYuanbaoUserId(groupCode);
-        if (yuanbaoUserId && refFromAccount === yuanbaoUserId) {
-            return false;
-        }
+    const classification = classifyReplyMode({ mode, refMsgId, refFromAccount, botYuanbaoUid });
+    if (classification === "no") {
+        return false;
     }
-    if (mode === "all") {
+    if (classification === "yes") {
         return true;
     }
     // "first" mode: only attach quote for the first reply to the same inbound message

package/dist/src/types.d.ts

@@ -93,6 +93,8 @@ export type YuanbaoMsgBodyElement = {
         url?: string;
         file_size?: number;
         file_name?: string;
+        /** Extension map, e.g. WeChat forwarded chat record detail for elem_type 1009. */
+        ext_map?: Record<string, string>;
         [key: string]: unknown;
     };
 };

package/openclaw.plugin.json

@@ -1,6 +1,6 @@
 {
   "id": "openclaw-plugin-yuanbao",
-  "version": "2.14.0",
+  "version": "2.15.0",
   "name": "YuanBao",
   "description": "YuanBao channel plugin",
   "channels": [