openclaw-plugin-yuanbao 2.14.0 → 2.16.0

package/README.md

@@ -18,7 +18,7 @@ through direct messages and group chats.
 
 ## Quick start
 
-> **Requires OpenClaw 2026.4.10 or above.** Run `openclaw --version` to check. Upgrade with `openclaw update`.
+> **Requires OpenClaw 2026.5.7 or above.** Run `openclaw --version` to check. Upgrade with `openclaw update`.
 
 ### 1. Add the Yuanbao channel with your credentials
 

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/actions/handler.js

@@ -15,6 +15,7 @@ import { resolveYuanbaoAccount } from "../../accounts.js";
 import { createLog } from "../../logger.js";
 import { getYuanbaoRuntime } from "../../runtime.js";
 import { createMessageSender } from "../outbound/create-sender.js";
+import { getActiveTraceContext } from "../trace/context.js";
 import { resolveActionTarget } from "./resolve-target.js";
 import { searchSticker } from "./sticker/send.js";
 /**
@@ -135,8 +136,14 @@ export async function handleAction(input) {
                 }
                 log.error(`${item.type} send failed: ${result.error}`);
             }
-            else if (result.messageId) {
-                lastMessageId = result.messageId;
+            else {
+                // Mark outbound delivered on the active agent-run trace context so
+                // dispatch-reply won't mistake an action-only reply (e.g. a sticker
+                // with no text) for an empty reply and send the fallback text.
+                getActiveTraceContext()?.markActionDelivered();
+                if (result.messageId) {
+                    lastMessageId = result.messageId;
+                }
             }
         }
         return { channel: "yuanbao", ok: true, messageId: lastMessageId };

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/dispatch-reply.js

@@ -202,7 +202,12 @@ export const dispatchReply = {
             }
             // ⭐ Flush outbound queue
             const flushed = await queueSession.flush();
-            if (!flushed && !hasSentContent && !ctx.abortSignal?.aborted) {
+            // The model may reply purely through a message action (e.g. sticker/react)
+            // which is delivered via handleAction and bypasses queueSession entirely.
+            // Such deliveries mark the agent-run trace context, so treat them as real
+            // outbound content and skip the fallback reply.
+            const deliveredViaAction = ctx.traceContext?.hasActionDelivered() ?? false;
+            if (!flushed && !hasSentContent && !deliveredViaAction && !ctx.abortSignal?.aborted) {
                 const { fallbackReply } = account;
                 if (fallbackReply) {
                     ctx.log.warn("[dispatch-reply] AI returned no reply content, using fallback reply");

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/business/tools/remind.js

@@ -222,10 +222,10 @@ function resolveCronBase(params, intent) {
 // ============================================================================
 /** Builds a Gateway job config for a one-time job. */
 function buildOnceJob(params, time, to, accountId, intent) {
-    const { name, atMs, message } = resolveOnceBase(params, time, intent);
+    const { name, atStr: at, message } = resolveOnceBase(params, time, intent);
     return {
         name,
-        schedule: { kind: 'at', atMs },
+        schedule: { kind: 'at', at },
         sessionTarget: 'isolated',
         wakeMode: 'now',
         deleteAfterRun: true,
@@ -411,7 +411,7 @@ async function executeGateway(gatewayTool, p, resolvedTo, accountId) {
             if (isCronExpression(p.time)) {
                 const job = buildCronJob({ ...p, content: p.content.trim() }, resolvedTo, accountId, intent);
                 try {
-                    const cronResult = await gatewayTool('cron.add', { timeoutMs: DEFAULT_GATEWAY_TIMEOUT_MS }, { job });
+                    const cronResult = await gatewayTool('cron.add', { timeoutMs: DEFAULT_GATEWAY_TIMEOUT_MS }, job);
                     const typeLabel = intent === 'task' ? '循环任务' : '周期提醒';
                     return json({
                         status: 'ok',
@@ -430,7 +430,7 @@ async function executeGateway(gatewayTool, p, resolvedTo, accountId) {
                 return json(timeResult);
             const job = buildOnceJob({ ...p, content: p.content.trim() }, timeResult.timeSpec, resolvedTo, accountId, intent);
             try {
-                const cronResult = await gatewayTool('cron.add', { timeoutMs: DEFAULT_GATEWAY_TIMEOUT_MS }, { job });
+                const cronResult = await gatewayTool('cron.add', { timeoutMs: DEFAULT_GATEWAY_TIMEOUT_MS }, job);
                 return json({
                     status: 'ok',
                     action: 'add',

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

@@ -4,6 +4,15 @@ export type YuanbaoTraceContext = {
     seqId?: string;
     /** Auto-incremented based on inbound seqId */
     nextMsgSeq: () => number | undefined;
+    /**
+     * Mark that an outbound message was successfully delivered via a message
+     * action (e.g. sticker/react/send) during this agent run. Used by
+     * dispatch-reply to avoid sending the fallback reply when the model already
+     * replied through an action rather than the deliver callback.
+     */
+    markActionDelivered: () => void;
+    /** Whether any action-driven outbound succeeded within this agent run. */
+    hasActionDelivered: () => boolean;
 };
 /**
  * Generate a random trace ID (32-char hex string).

package/dist/src/business/trace/context.js

@@ -59,6 +59,11 @@ export function resolveTraceContext(params) {
         seqCounter++;
         return baseSeq + seqCounter;
     };
+    let actionDelivered = false;
+    const markActionDelivered = () => {
+        actionDelivered = true;
+    };
+    const hasActionDelivered = () => actionDelivered;
     const log = createLog("trace");
     log.debug("[msg-trace] resolve context", {
         traceId,
@@ -69,6 +74,8 @@ export function resolveTraceContext(params) {
         traceId,
         traceparent: buildTraceparent(traceId),
         nextMsgSeq,
+        markActionDelivered,
+        hasActionDelivered,
         ...(seqId ? { seqId } : {}),
     };
 }