@youdu/openclaw-youdu 2026.5.9 → 2026.7.3

package/dist/index.esm.js

@@ -17,16 +17,20 @@ const plugin = {
     register(api) {
         setYouDuRuntime(api.runtime);
         api.registerChannel({ plugin: youduPlugin });
+        /** 有度频道系统指令 — 条件→动作格式，便于 LLM 精确遵循 */
+        const YOUDU_SYSTEM_CONTEXT_HINTS = [
+            "## 有度频道输出约束",
+            "",
+            "以下规则仅在当前频道（有度）生效：",
+            "",
+            "- 需要向用户发送图片/视频/语音/文件 → 必须使用 `MEDIA:` 指令输出；若不确定用法，调用 Skill 工具执行 `youdu-send-media`",
+            "- 需要生成图片或思维导图交付给用户 → 输出格式限 jpg / png / jpeg 三种之一",
+            "- 需要使用 /:awesome、/:happy 这类 emoji 快捷指令 → 调用 Skill 工具执行 `chat-emoji-conventions` 查询可用列表",
+        ];
         api.on("before_prompt_build", (_event, ctx) => {
-            if (ctx?.channelId !== CHANNEL_ID) {
+            if (ctx?.channelId !== CHANNEL_ID)
                 return;
-            }
-            return {
-                appendSystemContext: [
-                    "重要：涉及发送图片/视频/语音/文件给用户时，请务必使用 `MEDIA：` 指令。详见  youdu-send-media 这个 skill（技能）。",
-                    "重要: 若涉及需要生成图片(或思维导图)交付给用户时，生成图片的格式为jpg, png, jpeg中的一种",
-                ].join("\n"),
-            };
+            return { appendSystemContext: YOUDU_SYSTEM_CONTEXT_HINTS.join("\n") };
         });
     },
 };

package/dist/src/const.d.ts

@@ -13,8 +13,16 @@ export declare const TEXT_CHUNK_LIMIT = 4000;
 export declare const WS_HEARTBEAT_INTERVAL_MS = 30000;
 /** WebSocket 最大重连次数 */
 export declare const WS_MAX_RECONNECT_ATTEMPTS = 10;
-/** 消息处理总超时时间（毫秒） */
+/** 消息处理总超时时间（毫秒，被两级超时机制取代，保留兼容） */
 export declare const MESSAGE_PROCESS_TIMEOUT_MS: number;
+/** 第一级超时：警告阈值（毫秒）- 10 分钟，发送提示后任务继续 */
+export declare const WARNING_TIMEOUT_MS: number;
+/** 第二级超时：中止阈值（毫秒）- 20 分钟，发送提示后强制中断 */
+export declare const ABORT_TIMEOUT_MS: number;
+/** 超时警告提示 */
+export declare const WARNING_MESSAGE = "\u5904\u7406\u65F6\u95F4\u8F83\u957F\uFF0C\u8BF7\u7A0D\u7B49\uFF0C\u6B63\u5728\u751F\u6210\u6700\u7EC8\u7ED3\u679C...";
+/** 超时中止提示 */
+export declare const ABORT_MESSAGE = "\u5904\u7406\u65F6\u95F4\u8D85\u65F6\uFF0C\u8BF7\u7A0D\u540E\u91CD\u8BD5";
 /** "思考中"流式消息占位内容 */
 export declare const THINKING_MESSAGE = "<think></think>";
 /** 消息状态清理间隔（毫秒） */

package/dist/src/const.js

@@ -16,8 +16,14 @@ const TEXT_CHUNK_LIMIT = 4000;
 const WS_HEARTBEAT_INTERVAL_MS = 30000;
 /** WebSocket 最大重连次数 */
 const WS_MAX_RECONNECT_ATTEMPTS = 10;
-/** 消息处理总超时时间（毫秒） */
-const MESSAGE_PROCESS_TIMEOUT_MS = 5 * 60 * 1000;
+/** 第一级超时：警告阈值（毫秒）- 10 分钟，发送提示后任务继续 */
+const WARNING_TIMEOUT_MS = 10 * 60 * 1000;
+/** 第二级超时：中止阈值（毫秒）- 20 分钟，发送提示后强制中断 */
+const ABORT_TIMEOUT_MS = 20 * 60 * 1000;
+/** 超时警告提示 */
+const WARNING_MESSAGE = '处理时间较长，请稍等，正在生成最终结果...';
+/** 超时中止提示 */
+const ABORT_MESSAGE = '处理时间超时，请稍后重试';
 /** "思考中"流式消息占位内容 */
 const THINKING_MESSAGE = '<think></think>';
 /** 消息状态清理间隔（毫秒） */
@@ -29,4 +35,4 @@ const MEDIA_DOCUMENT_PLACEHOLDER = "<media:document>";
 /** 最大的媒体传输大小 */
 const DEFAULT_MEDIA_MAX_SIZE = 12 * 1024 * 1024; // 12MB
 
-export { CHANNEL_ID, DEFAULT_DM_POLICY, DEFAULT_MEDIA_MAX_SIZE, DOWNLOAD_MEDIA_URL, HTTP_SCHEME, MEDIA_DOCUMENT_PLACEHOLDER, MEDIA_IMAGE_PLACEHOLDER, MESSAGE_PROCESS_TIMEOUT_MS, MESSAGE_STATE_CLEANUP_INTERVAL_MS, PORT, TEXT_CHUNK_LIMIT, THINKING_MESSAGE, UPLOAD_MEDIA_URL, WEBSOCKET_SCHEME, WS_HEARTBEAT_INTERVAL_MS, WS_MAX_RECONNECT_ATTEMPTS, WS_URL };
+export { ABORT_MESSAGE, ABORT_TIMEOUT_MS, CHANNEL_ID, DEFAULT_DM_POLICY, DEFAULT_MEDIA_MAX_SIZE, DOWNLOAD_MEDIA_URL, HTTP_SCHEME, MEDIA_DOCUMENT_PLACEHOLDER, MEDIA_IMAGE_PLACEHOLDER, MESSAGE_STATE_CLEANUP_INTERVAL_MS, PORT, TEXT_CHUNK_LIMIT, THINKING_MESSAGE, UPLOAD_MEDIA_URL, WARNING_MESSAGE, WARNING_TIMEOUT_MS, WEBSOCKET_SCHEME, WS_HEARTBEAT_INTERVAL_MS, WS_MAX_RECONNECT_ATTEMPTS, WS_URL };

package/dist/src/message-prepare.d.ts

@@ -0,0 +1,219 @@
+import type { Youdu } from './media.js';
+/** text[] 数组中的单个元素 — 支持 txt / em / img 混排 */
+export interface YouduTextElement {
+    txt?: string;
+    em?: string;
+    img?: {
+        id: string;
+        name: string;
+        size?: number;
+        width?: number;
+        height?: number;
+        isGif?: boolean;
+    };
+}
+/** 引用消息体（被回复的那条消息），raw.decoded.reference */
+export interface YouduReferenceBody {
+    msgId: number;
+    sender: number;
+    senderName: string;
+    sessionId: string;
+    text: YouduTextElement[];
+    time: number;
+}
+/** raw.decoded 顶层结构（同时覆盖合并消息和引用消息的字段） */
+export interface YouduDecodedBody {
+    msgType: number;
+    atUser?: number[];
+    /** 引用消息（被回复的那条消息），msgType=10 时存在 */
+    reference?: YouduReferenceBody;
+    /** 消息内容数组，支持 txt / em / img 混排 */
+    text?: YouduTextElement[];
+    /** 合并消息（msgType=12）的聊天记录列表 */
+    list?: MergedMessageListItem[];
+    /** 合并消息标题 */
+    title?: string;
+    id?: string;
+    name?: string;
+    size?: number;
+    isDraft?: boolean | null;
+    [key: string]: unknown;
+}
+/** 合并消息中 list 的原始条目 */
+export interface MergedMessageListItem {
+    sender: number;
+    senderName: string;
+    sessType: number;
+    sendTime: number;
+    content: string;
+    [key: string]: unknown;
+}
+/** 合并消息中子消息解码后的内容体 */
+export interface MergedSubMessageContent {
+    text?: Array<{
+        txt?: string;
+        em?: string;
+        img?: {
+            id: string;
+            name: string;
+            size?: number;
+            width?: number;
+            height?: number;
+            isGif?: boolean;
+        };
+    }>;
+    msgType: number;
+    isDraft?: boolean;
+    id?: string;
+    name?: string;
+    size?: number;
+    isFolder?: boolean;
+    expired?: boolean;
+    isTemp?: boolean;
+    [key: string]: unknown;
+}
+/** 解析后的单条子消息（合并消息内部使用） */
+export interface ParsedSubMessage {
+    text: string;
+    media: Youdu.InboundMediaAttachment[];
+    sender: number;
+    senderName: string;
+    sendTime: number;
+}
+/** 合并消息解析结果（内部使用） */
+export interface ParsedMergedResult {
+    textParts: string[];
+    mediaAttachments: Youdu.InboundMediaAttachment[];
+    subMessages: ParsedSubMessage[];
+    subMessageCount: number;
+}
+/** parseDecodedBody 的解析结果 */
+export interface ParsedDecodedMessage {
+    originalText: string;
+    originalMedia: Youdu.InboundMediaAttachment[];
+    reference?: {
+        text: string;
+        media: Youdu.InboundMediaAttachment[];
+        sender: number;
+        senderName: string;
+        time: number;
+    };
+}
+/** prepareMessageBody() 的统一返回类型 */
+export interface PreparedMessageBody {
+    /** AI 可读的纯文本（可能已包含引用上下文或合并消息格式） */
+    text: string;
+    /** 需要下载并传给 AI 的媒体附件列表 */
+    media: Youdu.InboundMediaAttachment[];
+}
+/** 根据文件名后缀推断 content-type */
+export declare function inferContentTypeFromName(name: string): string | undefined;
+/** 将 Unix 毫秒时间戳格式化为本地日期时间字符串 */
+export declare function formatTimestamp(ms: number): string;
+/** 格式化文件大小为人类可读形式 */
+export declare function formatFileSize(bytes: number): string;
+/**
+ * 解析 text[] 数组，提取纯文本和媒体附件。
+ *
+ * text[] 中的元素类型：
+ * - txt: 纯文本内容，直接拼接
+ * - em:  表情代码，格式化为 "[表情: /:happy]"
+ * - img: 图片，生成 "[图片: xxx.png]" 占位文本，同时提取为附件
+ */
+export declare function parseTextElements(elements: YouduTextElement[]): {
+    text: string;
+    media: Youdu.InboundMediaAttachment[];
+};
+/**
+ * 解析合并消息（msgType === 12）。
+ *
+ * 解析策略：逐条遍历 list[]，对每条子消息：
+ * 1. base64 解码 content
+ * 2. 遍历 text[] 数组（通用容器，可混排 txt/em/img）
+ * 3. 文件类型（msgType=3）单独处理
+ */
+export declare function parseMergedMessage(body: {
+    msgType?: unknown;
+    list?: unknown;
+    title?: unknown;
+    [key: string]: unknown;
+}): ParsedMergedResult | null;
+/**
+ * 解析 raw.decoded 为结构化消息（仅用于引用消息 msgType=10）。
+ *
+ * 同时解析 reference（被引用内容）和 text（原文），
+ * 注意：不对 msgType=0 做特殊处理。
+ */
+export declare function parseDecodedBody(decoded: YouduDecodedBody): ParsedDecodedMessage;
+/**
+ * 格式化合并消息为 AI 可读的文本。
+ */
+export declare function formatMergedText(result: ParsedMergedResult, title?: string): string;
+/**
+ * 构建 AI 可读的引用消息上下文文本。
+ *
+ * 当存在引用消息时，生成以下格式：
+ * ```text
+ * 用户回复了一条消息，请结合以下上下文理解用户意图：
+ *
+ * 被回复的消息（发送者: 6hhhuhh，时间: 2026-06-14 10:58:05）：
+ * <引用消息内容>
+ *
+ * 用户当前消息（发送者: coco）：
+ * <用户回复内容>
+ *
+ * 请结合上述对话上下文理解用户的意图，并给出恰当的回复。
+ * ```
+ */
+export declare function formatMessageWithReference(parsed: ParsedDecodedMessage, currentUserName: string): {
+    text: string;
+    allMedia: Youdu.InboundMediaAttachment[];
+};
+/**
+ * 消息体类型（prepareMessageBody 的输入参数）
+ */
+export interface YouDuMessageBody {
+    msgId?: string;
+    msgType?: string;
+    chatType?: 'single' | 'group';
+    chatId?: string;
+    from?: {
+        userId?: string;
+        account?: string;
+        name?: string;
+    };
+    createTime?: number;
+    text?: {
+        content?: string;
+    };
+    image?: Youdu.MediaBody;
+    file?: Youdu.MediaBody;
+    audio?: Youdu.MediaBody;
+    video?: Youdu.MediaBody;
+    media?: Array<Youdu.MediaBody & {
+        kind?: string;
+    }>;
+    raw?: {
+        decoded?: YouduDecodedBody;
+    };
+    [key: string]: any;
+}
+/**
+ * 统一消息准备入口。
+ *
+ * 根据消息体内容自动判断消息类型并完成解析，返回 AI 可消费的
+ * 纯文本 + 媒体附件列表。调用方无需关心底层消息类型。
+ *
+ * 处理流程：
+ * 1. 从 body 顶层字段提取直接媒体和文本（保持原有逻辑）
+ * 2. 检查 raw.decoded：
+ *    - msgType=12 → 合并消息解析，覆盖 text 和 media
+ *    - msgType=10 → 引用消息解析，覆盖 text 和 media
+ *    - 其他 msgType（含 msgType=0）→ 不做特殊处理
+ * 3. 合并顶层媒体和 decoded 解析出的媒体
+ *
+ * @param body       消息体（WsFrame.body）
+ * @param currentUserName  当前消息发送者名称（引用消息格式化时需要）
+ * @returns 统一结果 { text, media }
+ */
+export declare function prepareMessageBody(body: YouDuMessageBody, currentUserName?: string): PreparedMessageBody;

package/dist/src/message-prepare.js

@@ -0,0 +1,395 @@
+import { extractInboundMedia, inferInboundMessageText } from './media.js';
+
+/*
+ * Licensed under the MIT License.
+ *
+ * 有度消息统一解析器
+ *
+ * 所有消息内容的解析与格式化在此文件中集中管理。
+ * 入口函数 prepareMessageBody() 根据消息体类型自动分发，
+ * 返回统一的 { text, media } 结果，调用方无需关心底层消息类型。
+ *
+ * 支持的消息类型：
+ * - msgType=12（合并消息/聊天记录转发）
+ * - msgType=10（引用消息/回复）
+ * - msgType=1/3/其他（图片/文件/普通消息等，走 body 顶层字段提取）
+ *
+ * 普通文本消息（msgType=0）不在此做特殊处理，
+ * 直接走 body.text.content，与原有逻辑保持一致。
+ */
+// ============================================================================
+// 2. 共享工具函数
+// ============================================================================
+/** 根据文件名后缀推断 content-type */
+function inferContentTypeFromName(name) {
+    const ext = name.split('.').pop()?.toLowerCase();
+    const map = {
+        png: 'image/png',
+        jpg: 'image/jpeg',
+        jpeg: 'image/jpeg',
+        gif: 'image/gif',
+        webp: 'image/webp',
+        bmp: 'image/bmp',
+        svg: 'image/svg+xml',
+    };
+    return map[ext ?? ''];
+}
+/** 将 Unix 毫秒时间戳格式化为本地日期时间字符串 */
+function formatTimestamp(ms) {
+    if (!ms)
+        return '';
+    try {
+        const d = new Date(ms);
+        const pad = (n) => String(n).padStart(2, '0');
+        return `${d.getFullYear()}-${pad(d.getMonth() + 1)}-${pad(d.getDate())} ${pad(d.getHours())}:${pad(d.getMinutes())}:${pad(d.getSeconds())}`;
+    }
+    catch {
+        return String(ms);
+    }
+}
+/** 格式化文件大小为人类可读形式 */
+function formatFileSize(bytes) {
+    if (bytes < 1024) {
+        return `${bytes}B`;
+    }
+    if (bytes < 1024 * 1024) {
+        return `${(bytes / 1024).toFixed(1)}KB`;
+    }
+    return `${(bytes / 1024 / 1024).toFixed(1)}MB`;
+}
+// ============================================================================
+// 3. 底层解析函数
+// ============================================================================
+/**
+ * 解析 text[] 数组，提取纯文本和媒体附件。
+ *
+ * text[] 中的元素类型：
+ * - txt: 纯文本内容，直接拼接
+ * - em:  表情代码，格式化为 "[表情: /:happy]"
+ * - img: 图片，生成 "[图片: xxx.png]" 占位文本，同时提取为附件
+ */
+function parseTextElements(elements) {
+    const textParts = [];
+    const media = [];
+    for (const entry of elements) {
+        if (!entry || typeof entry !== 'object') {
+            continue;
+        }
+        // 文本段
+        if (typeof entry.txt === 'string' && entry.txt) {
+            textParts.push(entry.txt);
+            continue;
+        }
+        // 表情段
+        if (typeof entry.em === 'string' && entry.em) {
+            textParts.push(`[表情: ${entry.em}]`);
+            continue;
+        }
+        // 图片段
+        if (entry.img && typeof entry.img.id === 'string' && entry.img.id) {
+            const imgName = typeof entry.img.name === 'string' ? entry.img.name : '图片';
+            textParts.push(`[图片: ${imgName}]`);
+            media.push({
+                kind: 'image',
+                mediaId: entry.img.id,
+                name: imgName,
+                size: typeof entry.img.size === 'number' ? entry.img.size : undefined,
+                width: typeof entry.img.width === 'number' ? entry.img.width : undefined,
+                height: typeof entry.img.height === 'number' ? entry.img.height : undefined,
+                contentType: inferContentTypeFromName(imgName),
+            });
+            continue;
+        }
+    }
+    return { text: textParts.join(''), media };
+}
+/**
+ * 安全解码 base64 字符串，失败时返回 null。
+ *
+ * 编码兼容：先尝试 UTF-8 解码。若 JSON.parse 校验失败，再尝试 GBK 编码
+ *（有度早期版本的部分消息使用 GBK 编码的中文文本）。
+ */
+function safeBase64Decode(encoded) {
+    if (!encoded || typeof encoded !== 'string') {
+        return null;
+    }
+    if (!/^[A-Za-z0-9+/=]*$/.test(encoded)) {
+        return null;
+    }
+    try {
+        const buf = Buffer.from(encoded, 'base64');
+        if (buf.length === 0) {
+            return null;
+        }
+        // 1) 尝试 UTF-8 解码
+        const utf8Str = buf.toString('utf-8');
+        if (utf8Str) {
+            try {
+                JSON.parse(utf8Str);
+                return utf8Str;
+            }
+            catch {
+                // 不是合法 JSON → 可能是 GBK 编码
+            }
+        }
+        // 2) GBK 回退
+        try {
+            const gbkStr = new TextDecoder('gbk').decode(buf);
+            if (gbkStr) {
+                JSON.parse(gbkStr);
+                return gbkStr;
+            }
+        }
+        catch {
+            // GBK 也失败
+        }
+        return null;
+    }
+    catch {
+        return null;
+    }
+}
+// ============================================================================
+// 4. 合并消息解析（msgType=12）
+// ============================================================================
+/** 合并消息的 msgType 值 */
+const MERGED_MESSAGE_MSG_TYPE = 12;
+/**
+ * 解析合并消息（msgType === 12）。
+ *
+ * 解析策略：逐条遍历 list[]，对每条子消息：
+ * 1. base64 解码 content
+ * 2. 遍历 text[] 数组（通用容器，可混排 txt/em/img）
+ * 3. 文件类型（msgType=3）单独处理
+ */
+function parseMergedMessage(body) {
+    if (body?.msgType !== MERGED_MESSAGE_MSG_TYPE) {
+        return null;
+    }
+    const rawList = body.list;
+    if (!Array.isArray(rawList) || rawList.length === 0) {
+        return null;
+    }
+    const result = {
+        textParts: [],
+        mediaAttachments: [],
+        subMessages: [],
+        subMessageCount: rawList.length,
+    };
+    for (let i = 0; i < rawList.length; i++) {
+        const item = rawList[i];
+        const sender = typeof item.sender === 'number' ? item.sender : 0;
+        const senderName = (typeof item.senderName === 'string' ? item.senderName : '').trim();
+        const sendTime = typeof item.sendTime === 'number' ? item.sendTime : 0;
+        const encodedContent = typeof item.content === 'string' ? item.content : '';
+        // base64 解码
+        const decodedStr = safeBase64Decode(encodedContent);
+        if (decodedStr === null) {
+            continue;
+        }
+        // JSON 解析
+        let decoded;
+        try {
+            decoded = JSON.parse(decodedStr);
+        }
+        catch {
+            // 非 JSON 文本，作为纯文本展示
+            const textLine = decodedStr;
+            result.textParts.push(textLine);
+            result.subMessages.push({ text: textLine, media: [], sender, senderName, sendTime });
+            continue;
+        }
+        const subTextParts = [];
+        const subMedia = [];
+        // 分支 A：有 text[] 数组（msgType=0 文本/表情/混排 或 msgType=1 图片）
+        if (Array.isArray(decoded.text) && decoded.text.length > 0) {
+            const parsed = parseTextElements(decoded.text);
+            subTextParts.push(parsed.text);
+            subMedia.push(...parsed.media);
+        }
+        // 分支 B：文件类型（msgType=3，无 text[]，顶层 id/name/size）
+        const subMsgType = typeof decoded.msgType === 'number' ? decoded.msgType : -1;
+        if (subMsgType === 3 && typeof decoded.id === 'string' && decoded.id) {
+            const fileName = typeof decoded.name === 'string' ? decoded.name : '文件';
+            const fileSize = typeof decoded.size === 'number' ? decoded.size : undefined;
+            const sizeLabel = fileSize !== undefined ? ` (${formatFileSize(fileSize)})` : '';
+            subTextParts.push(`[文件: ${fileName}]${sizeLabel}`);
+            subMedia.push({
+                kind: 'file',
+                mediaId: decoded.id,
+                name: fileName,
+                size: fileSize,
+                contentType: inferContentTypeFromName(fileName),
+            });
+        }
+        // 分支 C：完全未知的 msgType，兜底
+        if (subTextParts.length === 0 && subMedia.length === 0) {
+            subTextParts.push(JSON.stringify(decoded));
+        }
+        const lineText = subTextParts.join('');
+        result.textParts.push(lineText);
+        result.mediaAttachments.push(...subMedia);
+        result.subMessages.push({
+            text: lineText,
+            media: subMedia,
+            sender,
+            senderName,
+            sendTime,
+        });
+    }
+    if (result.subMessages.length === 0) {
+        return null;
+    }
+    result.subMessageCount = result.subMessages.length;
+    return result;
+}
+// ============================================================================
+// 5. 引用消息解析（msgType=10）
+// ============================================================================
+/**
+ * 解析 raw.decoded 为结构化消息（仅用于引用消息 msgType=10）。
+ *
+ * 同时解析 reference（被引用内容）和 text（原文），
+ * 注意：不对 msgType=0 做特殊处理。
+ */
+function parseDecodedBody(decoded) {
+    const original = parseTextElements(decoded.text ?? []);
+    let reference;
+    if (decoded.reference) {
+        const refContent = parseTextElements(decoded.reference.text);
+        reference = {
+            text: refContent.text,
+            media: refContent.media,
+            sender: decoded.reference.sender,
+            senderName: decoded.reference.senderName,
+            time: decoded.reference.time,
+        };
+    }
+    return {
+        originalText: original.text,
+        originalMedia: original.media,
+        reference,
+    };
+}
+// ============================================================================
+// 6. 格式化函数
+// ============================================================================
+/**
+ * 格式化合并消息为 AI 可读的文本。
+ */
+function formatMergedText(result, title) {
+    const header = `聊天记录: ${title ?? ''}`;
+    const lines = result.subMessages.map((msg) => {
+        const timeStr = formatTimestamp(msg.sendTime);
+        const senderLabel = msg.senderName
+            ? `${msg.sender}(${msg.senderName})`
+            : String(msg.sender);
+        return `[${timeStr}] ${senderLabel}: ${msg.text}`;
+    });
+    const body = [header, ...lines].join('\n');
+    return [
+        '用户分享了一段聊天记录。请先完整阅读聊天记录，然后对聊天记录中的对话内容做简要总结，最后主动询问用户的意图或需要你帮忙完成什么任务。',
+        '',
+        body,
+    ].join('\n');
+}
+/**
+ * 构建 AI 可读的引用消息上下文文本。
+ *
+ * 当存在引用消息时，生成以下格式：
+ * ```text
+ * 用户回复了一条消息，请结合以下上下文理解用户意图：
+ *
+ * 被回复的消息（发送者: 6hhhuhh，时间: 2026-06-14 10:58:05）：
+ * <引用消息内容>
+ *
+ * 用户当前消息（发送者: coco）：
+ * <用户回复内容>
+ *
+ * 请结合上述对话上下文理解用户的意图，并给出恰当的回复。
+ * ```
+ */
+function formatMessageWithReference(parsed, currentUserName) {
+    if (!parsed.reference) {
+        return {
+            text: parsed.originalText || '',
+            allMedia: parsed.originalMedia,
+        };
+    }
+    const ref = parsed.reference;
+    const refSenderLabel = ref.senderName || String(ref.sender);
+    const refTimeStr = formatTimestamp(ref.time);
+    const userName = currentUserName || '未知用户';
+    const text = [
+        '用户回复了一条消息，请结合以下上下文理解用户意图：',
+        '',
+        `被回复的消息（发送者: ${refSenderLabel}，时间: ${refTimeStr}）：`,
+        ref.text || '(空消息)',
+        '',
+        `用户当前消息（发送者: ${userName}）：`,
+        parsed.originalText || '(空消息)',
+        '',
+        '请结合上述对话上下文理解用户的意图，并给出恰当的回复。',
+    ].join('\n');
+    return {
+        text,
+        allMedia: [...parsed.originalMedia, ...ref.media],
+    };
+}
+/**
+ * 统一消息准备入口。
+ *
+ * 根据消息体内容自动判断消息类型并完成解析，返回 AI 可消费的
+ * 纯文本 + 媒体附件列表。调用方无需关心底层消息类型。
+ *
+ * 处理流程：
+ * 1. 从 body 顶层字段提取直接媒体和文本（保持原有逻辑）
+ * 2. 检查 raw.decoded：
+ *    - msgType=12 → 合并消息解析，覆盖 text 和 media
+ *    - msgType=10 → 引用消息解析，覆盖 text 和 media
+ *    - 其他 msgType（含 msgType=0）→ 不做特殊处理
+ * 3. 合并顶层媒体和 decoded 解析出的媒体
+ *
+ * @param body       消息体（WsFrame.body）
+ * @param currentUserName  当前消息发送者名称（引用消息格式化时需要）
+ * @returns 统一结果 { text, media }
+ */
+function prepareMessageBody(body, currentUserName) {
+    // Step 1: 提取顶层媒体和基础文本（保持原有逻辑）
+    let inboundMedia = extractInboundMedia(body);
+    let text = inferInboundMessageText(body);
+    // Step 2: 检查 raw.decoded，处理特殊消息类型
+    const rawDecoded = body.raw?.decoded;
+    if (rawDecoded) {
+        // 合并消息（msgType=12）
+        if (rawDecoded.msgType === MERGED_MESSAGE_MSG_TYPE && Array.isArray(rawDecoded.list)) {
+            const mergedResult = parseMergedMessage(rawDecoded);
+            if (mergedResult) {
+                text = formatMergedText(mergedResult, rawDecoded.title);
+                if (mergedResult.mediaAttachments.length > 0) {
+                    inboundMedia = mergedResult.mediaAttachments;
+                }
+            }
+        }
+        // 引用消息（msgType=10）
+        else if (rawDecoded.msgType === 10) {
+            const parsed = parseDecodedBody(rawDecoded);
+            if (parsed.reference) {
+                const userName = currentUserName || body.from?.name || body.from?.account || '';
+                const formatted = formatMessageWithReference(parsed, userName);
+                text = formatted.text;
+                if (formatted.allMedia.length > 0) {
+                    inboundMedia = formatted.allMedia;
+                }
+            }
+            else if (parsed.originalText && !text) {
+                // 有 decoded.text 但没有 reference，兜底使用解析出的文本
+                text = parsed.originalText;
+            }
+        }
+    }
+    // Step 3: 返回统一结果
+    return { text, media: inboundMedia };
+}
+
+export { formatFileSize, formatMergedText, formatMessageWithReference, formatTimestamp, inferContentTypeFromName, parseDecodedBody, parseMergedMessage, parseTextElements, prepareMessageBody };

package/dist/src/monitor.d.ts

@@ -2,6 +2,7 @@ import type { OpenClawConfig } from "openclaw/plugin-sdk/core";
 import type { RuntimeEnv } from "openclaw/plugin-sdk/runtime-env";
 import { ResolvedYouDuAccount } from './utils.js';
 import { type Youdu } from './media.js';
+import { type YouduDecodedBody } from './message-prepare.js';
 /**
  * 消息体类型（待用户完善）
  */
@@ -27,6 +28,10 @@ export interface YouDuMessageBody {
     media?: Array<Youdu.MediaBody & {
         kind?: string;
     }>;
+    /** 消息原始解码数据。raw.decoded 包含合并消息/引用消息等结构 */
+    raw?: {
+        decoded?: YouduDecodedBody;
+    };
     [key: string]: any;
 }
 /**

package/dist/src/monitor.js

@@ -1,14 +1,15 @@
 import { WSClient } from './sdk/ws-client.js';
 import { getYouDuRuntime } from './runtime.js';
 import { resolveYouDuAccount } from './utils.js';
-import { WS_MAX_RECONNECT_ATTEMPTS, WS_HEARTBEAT_INTERVAL_MS, PORT, THINKING_MESSAGE, MESSAGE_PROCESS_TIMEOUT_MS, CHANNEL_ID, MEDIA_IMAGE_PLACEHOLDER, MEDIA_DOCUMENT_PLACEHOLDER } from './const.js';
+import { WS_MAX_RECONNECT_ATTEMPTS, WS_HEARTBEAT_INTERVAL_MS, PORT, THINKING_MESSAGE, ABORT_TIMEOUT_MS, ABORT_MESSAGE, WARNING_TIMEOUT_MS, WARNING_MESSAGE, CHANNEL_ID, MEDIA_IMAGE_PLACEHOLDER, MEDIA_DOCUMENT_PLACEHOLDER } from './const.js';
 import { buildYouDuTlsConnectOptions } from './tls.js';
 import { cleanupAccount, startMessageStateCleanup, setYouDuWebSocket, stopMessageStateCleanup, rememberDirectChatTarget, setMessageState, deleteMessageState } from './state-manager.js';
 import { checkDmPolicy } from './dm-policy.js';
 import { checkGroupPolicy } from './group-policy.js';
-import { extractInboundMedia, inferInboundMessageText, downloadInboundMedia, uploadAndSendMedia, resolveYouDuMediaLocalRoots } from './media.js';
+import { downloadInboundMedia, uploadAndSendMedia, resolveYouDuMediaLocalRoots } from './media.js';
 import { sendYouDuReply } from './message-sender.js';
 import { generateReqId } from './sdk/ws-utils.js';
+import { prepareMessageBody } from './message-prepare.js';
 
 /*
 * Licensed under the MIT License.
@@ -88,12 +89,13 @@ async function processYouDuMessage(params) {
     if (chatType === "direct" && chatId && youduAccount) {
         rememberDirectChatTarget(account.accountId, youduAccount, chatId);
     }
-    let text = '';
-    const inboundMedia = extractInboundMedia(body);
-    text = inferInboundMessageText(body);
+    // 统一消息解析入口：处理合并消息（msgType=12）、引用消息（msgType=10）和普通消息
+    const currentUserName = body.from.name || body.from.account;
+    const prepared = prepareMessageBody(body, currentUserName);
+    const text = prepared.text;
+    const inboundMedia = prepared.media;
     // 如果消息和附件都为空，跳过处理
     if (!text && inboundMedia.length === 0) {
-        runtime.log?.('[youdu][plugin] Skipping empty message');
         return;
     }
     // 群组策略检查 （群聊）
@@ -153,7 +155,7 @@ async function processYouDuMessage(params) {
     // 构建上下文并路由到 OpenClaw 核心处理
     const ctxPayload = buildMessageContext(frame, account, config, text, mediaList);
     try {
-        await processWithTimeout(routeAndDispatchMessage({
+        await processWithTimeoutGuard(() => routeAndDispatchMessage({
             ctxPayload,
             config,
             account,
@@ -162,23 +164,40 @@ async function processYouDuMessage(params) {
             state,
             runtime,
             onCleanup: cleanupState,
-        }), MESSAGE_PROCESS_TIMEOUT_MS);
+        }), {
+            warningMs: WARNING_TIMEOUT_MS,
+            abortMs: ABORT_TIMEOUT_MS,
+            onWarning: async () => {
+                runtime.log?.(`[youdu] Task running for ${WARNING_TIMEOUT_MS / 1000 / 60} min, sending warning`);
+                await sendYouDuReply({ wsClient, frame, text: WARNING_MESSAGE, runtime });
+            },
+            onAbort: async () => {
+                runtime.log?.(`[youdu] Task running for ${ABORT_TIMEOUT_MS / 1000 / 60} min, aborting`);
+                state.timedOut = true;
+                await sendYouDuReply({ wsClient, frame, text: ABORT_MESSAGE, runtime });
+            },
+        });
     }
     catch (err) {
-        runtime.error?.(`[youdu][plugin] Message processing failed: ${String(err)}`);
-        // 确保 thinking 流被关闭
-        try {
-            if (shouldSendThinking) {
-                await sendYouDuReply({
-                    wsClient,
-                    frame,
-                    text: '处理消息时出现异常，请稍后重试。',
-                    runtime,
-                });
-            }
+        // 超时中止错误已在 onAbort 中发送提示，不再重复发送
+        if (state.timedOut) {
+            runtime.error?.(`[youdu][plugin] Message processing timed out after ${ABORT_TIMEOUT_MS / 1000 / 60} min`);
         }
-        catch (finishErr) {
-            runtime.error?.(`[youdu] Failed to finish thinking stream on error: ${String(finishErr)}`);
+        else {
+            runtime.error?.(`[youdu][plugin] Message processing failed: ${String(err)}`);
+            try {
+                if (shouldSendThinking) {
+                    await sendYouDuReply({
+                        wsClient,
+                        frame,
+                        text: '处理消息时出现异常，请稍后重试。',
+                        runtime,
+                    });
+                }
+            }
+            catch (finishErr) {
+                runtime.error?.(`[youdu] Failed to finish thinking stream on error: ${String(finishErr)}`);
+            }
         }
         cleanupState();
     }
@@ -203,6 +222,9 @@ async function routeAndDispatchMessage(params) {
             cfg: config,
             dispatcherOptions: {
                 deliver: async (payload, info) => {
+                    // 超时中止后不再处理后续交付
+                    if (state.timedOut)
+                        return;
                     state.deliverCalled = true;
                     // 累积文本
                     if (payload.text) {
@@ -275,6 +297,9 @@ function buildMediaErrorSummary(mediaUrl, errMsg) {
 }
 async function finishThinkingStream(ctx) {
     const { wsClient, frame, state, runtime } = ctx;
+    // 超时中止后不再发送最终回复
+    if (state.timedOut)
+        return;
     let finishText = state.accumulatedText;
     if (finishText) {
         await sendYouDuReply({ wsClient, frame, text: finishText, runtime });
@@ -307,13 +332,53 @@ async function finishThinkingStream(ctx) {
     }
 }
 /**
- * 带超时的 Promise 处理
+ * 两级超时保护
+ *
+ * 第一级（warningMs）：发送提示消息，任务继续执行
+ * 第二级（abortMs）：发送中止消息，强制中断任务
  */
-async function processWithTimeout(promise, timeoutMs) {
-    return Promise.race([
-        promise,
-        new Promise((_, reject) => setTimeout(() => reject(new Error(`Timeout after ${timeoutMs}ms`)), timeoutMs)),
-    ]);
+async function processWithTimeoutGuard(task, options) {
+    return new Promise((resolve, reject) => {
+        let finished = false;
+        const warningTimer = setTimeout(async () => {
+            if (finished)
+                return;
+            try {
+                await options.onWarning();
+            }
+            catch {
+                // 警告发送失败不影响主流程
+            }
+        }, options.warningMs);
+        const abortTimer = setTimeout(async () => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(warningTimer);
+            try {
+                await options.onAbort();
+            }
+            catch {
+                // 中止消息发送失败仍要 reject
+            }
+            reject(new Error('Task aborted after timeout'));
+        }, options.abortMs);
+        task().then((result) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(warningTimer);
+            clearTimeout(abortTimer);
+            resolve(result);
+        }, (error) => {
+            if (finished)
+                return;
+            finished = true;
+            clearTimeout(warningTimer);
+            clearTimeout(abortTimer);
+            reject(error);
+        });
+    });
 }
 /**
  * 创建 SDK Logger 适配器

package/dist/src/sdk/ws-manager.js

@@ -97,9 +97,7 @@ class WsConnectionManager extends EventEmitter {
             let frame;
             try {
                 frame = JSON.parse(raw);
-                if (!frame.headers?.reqId.startsWith("ping")) {
-                    this.logger.info(`[WS] <<< Received message (${raw.length} chars): ${raw}`);
-                }
+                this.logger.info(`[WS] <<< Received message (${raw.length} chars): ${raw}`);
             }
             catch {
                 frame = {
@@ -137,6 +135,9 @@ class WsConnectionManager extends EventEmitter {
         this.ws.on("ping", () => {
             this.ws?.pong();
         });
+        this.ws.on("pong", () => {
+            this.missedPongCount = 0;
+        });
         this.logger.info("[WS] Event handlers registered");
     }
     sendAuth(forceSubscribe = false) {
@@ -255,17 +256,16 @@ class WsConnectionManager extends EventEmitter {
     }
     sendHeartbeat() {
         if (this.missedPongCount >= this.maxMissedPong) {
-            this.logger.warn(`No heartbeat ack received for ${this.missedPongCount} consecutive pings`);
+            this.logger.warn(`No heartbeat pong received for ${this.missedPongCount} consecutive pings`);
             this.stopHeartbeat();
             this.ws?.terminate();
             return;
         }
         this.missedPongCount++;
         try {
-            this.send({
-                cmd: WsCmd.HEARTBEAT,
-                headers: { reqId: generateReqId(WsCmd.HEARTBEAT), token: this.token },
-            });
+            if (this.ws && this.ws.readyState === WebSocket.OPEN) {
+                this.ws.ping();
+            }
         }
         catch (error) {
             this.logger.error("Failed to send heartbeat:", error.message);

package/dist/src/state-manager.d.ts

@@ -13,6 +13,8 @@ export interface MessageState {
     hasMediaFailed?: boolean;
     deliverCalled?: boolean;
     mediaErrorSummary?: string;
+    /** 标记是否已超时中止，true 时不再发送流式更新和最终回复 */
+    timedOut?: boolean;
 }
 /**
  * 设置账户的 WebSocket 客户端

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@youdu/openclaw-youdu",
-  "version": "2026.5.9",
+  "version": "2026.7.3",
   "type": "module",
   "main": "dist/index.esm.js",
   "module": "dist/index.esm.js",