@yaoqi10012/wechat-kf 0.3.1

package/dist/bot.js

@@ -0,0 +1,672 @@
+/**
+ * Message processing — pull messages via sync_msg and dispatch to OpenClaw agent.
+ *
+ * Architecture:
+ * - Each openKfId is an independent account with its own cursor and session
+ * - sync_msg is called with open_kfid filter to only pull messages for that kf account
+ * - Plugin layer: download media, save via MediaPaths/MediaTypes
+ * - OpenClaw runner: handles media understanding (transcription, vision, etc.)
+ */
+import { mkdir, readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { getChannelConfig, registerKfId, resolveAccount } from "./accounts.js";
+import { downloadMedia, sendTextMessage, syncMessages } from "./api.js";
+import { CHANNEL_ID, cursorFileName, formatError, logTag, MAX_MESSAGE_AGE_S } from "./constants.js";
+import { atomicWriteFile } from "./fs-utils.js";
+import { setPairingKfId } from "./monitor.js";
+import { createReplyDispatcher } from "./reply-dispatcher.js";
+import { getRuntime } from "./runtime.js";
+import { contentTypeToExt, detectImageMime } from "./send-utils.js";
+/**
+ * Backward-compatible wrapper for readAllowFromStore.
+ * OpenClaw >=2026.2.26 changed from positional args to object params.
+ * Try new API first; fall back to old positional API if result is empty.
+ */
+async function readAllowFromStoreCompat(core, channelId, accountId) {
+    const read = core.channel.pairing.readAllowFromStore;
+    const result = await read({ channel: channelId, accountId }).catch(() => []);
+    if (result.length > 0)
+        return result;
+    return read(channelId).catch(() => []);
+}
+// ── Per-kfId async mutex ──
+// Ensures that concurrent calls to handleWebhookEvent for the same openKfId
+// (e.g. from webhook + polling simultaneously) are serialized.
+const kfLocks = new Map();
+// ── Message deduplication ──
+// Tracks recently-processed msgids to avoid dispatching the same message twice,
+// even if sync_msg returns overlapping batches from concurrent paths.
+const processedMsgIds = new Set();
+const DEDUP_MAX_SIZE = 10_000;
+function isDuplicate(msgid) {
+    if (processedMsgIds.has(msgid))
+        return true;
+    if (processedMsgIds.size >= DEDUP_MAX_SIZE) {
+        // Evict the oldest half (Set preserves insertion order)
+        const entries = [...processedMsgIds];
+        processedMsgIds.clear();
+        for (const id of entries.slice(entries.length >>> 1)) {
+            processedMsgIds.add(id);
+        }
+    }
+    processedMsgIds.add(msgid);
+    return false;
+}
+// ── Inbound debounce ──
+const DEFAULT_DEBOUNCE_MS = 2000;
+let debouncer = null;
+function getOrCreateDebouncer(ctx) {
+    if (debouncer)
+        return debouncer;
+    const core = getRuntime();
+    const channelConfig = getChannelConfig(ctx.cfg);
+    const inbound = ctx.cfg.messages;
+    const hasExplicitDebounce = typeof inbound?.inbound?.debounceMs === "number" || typeof inbound?.inbound?.byChannel?.[CHANNEL_ID] === "number";
+    const debounceMs = hasExplicitDebounce
+        ? core.channel.debounce.resolveInboundDebounceMs({ cfg: ctx.cfg, channel: CHANNEL_ID })
+        : (channelConfig.debounceMs ?? DEFAULT_DEBOUNCE_MS);
+    debouncer = core.channel.debounce.createInboundDebouncer({
+        debounceMs,
+        buildKey: (item) => `${CHANNEL_ID}:${item.openKfId}:${item.externalUserId}`,
+        shouldDebounce: (item) => {
+            return !core.channel.text.hasControlCommand(item.text, item.ctx.cfg);
+        },
+        onFlush: async (items) => {
+            if (items.length === 0)
+                return;
+            if (items.length === 1) {
+                await dispatchPrepared(items[0]);
+                return;
+            }
+            await dispatchCombined(items);
+        },
+        onError: (err, items) => {
+            items[0]?.ctx.log?.error(`${logTag(items[0].openKfId)} debounce flush failed: ${formatError(err)}`);
+        },
+    });
+    return debouncer;
+}
+/** Exposed for testing only — do not use in production code. */
+export const _testing = {
+    kfLocks,
+    processedMsgIds,
+    isDuplicate,
+    DEDUP_MAX_SIZE,
+    handleEvent,
+    drainToLatestCursor,
+    resetState() {
+        kfLocks.clear();
+        processedMsgIds.clear();
+        debouncer = null;
+    },
+};
+// ── Cursor persistence (per kfid) ──
+async function loadCursor(stateDir, kfId) {
+    try {
+        return (await readFile(join(stateDir, cursorFileName(kfId)), "utf8")).trim();
+    }
+    catch {
+        return "";
+    }
+}
+let dirCreated = false;
+async function saveCursor(stateDir, kfId, cursor) {
+    if (!dirCreated) {
+        await mkdir(stateDir, { recursive: true });
+        dirCreated = true;
+    }
+    await atomicWriteFile(join(stateDir, cursorFileName(kfId)), cursor);
+}
+// ── Message text extraction ──
+// Descriptions of non-text messages injected into the AI agent's context.
+// Kept in Chinese because end-users are Chinese WeChat users and the agent
+// replies in Chinese. These are NOT displayed to end-users directly.
+function extractText(msg) {
+    switch (msg.msgtype) {
+        case "text": {
+            const textContent = msg.text?.content ?? "";
+            const menuId = msg.text?.menu_id;
+            return menuId ? `${textContent} [menu_id: ${menuId}]` : textContent;
+        }
+        case "image":
+            return "[用户发送了一张图片]";
+        case "voice":
+            return "[用户发送了一段语音]";
+        case "video":
+            return "[用户发送了一段视频]";
+        case "file":
+            return "[用户发送了一个文件]";
+        case "location": {
+            const loc = msg.location;
+            const parts = [loc?.name, loc?.address].filter(Boolean).join(" ");
+            const coords = loc?.latitude != null && loc?.longitude != null ? ` (${loc.latitude}, ${loc.longitude})` : "";
+            return parts ? `[位置: ${parts}${coords}]` : coords ? `[位置:${coords}]` : "[位置]";
+        }
+        case "link": {
+            const lk = msg.link;
+            const linkParts = [lk?.title, lk?.desc].filter(Boolean).join(" - ");
+            const url = lk?.url ?? "";
+            const pic = lk?.pic_url ? ` pic_url: ${lk.pic_url}` : "";
+            return `[链接: ${linkParts} ${url}${pic}]`;
+        }
+        case "merged_msg": {
+            const merged = msg.merged_msg;
+            if (!merged)
+                return "[转发的聊天记录]";
+            const title = merged.title ?? "聊天记录";
+            const items = Array.isArray(merged.item) ? merged.item : [];
+            const lines = items.map((item) => {
+                const sender = item.sender_name ?? "未知";
+                const timeStr = item.send_time
+                    ? ` (${new Date(item.send_time * 1000).toLocaleString("zh-CN", { hour12: false })})`
+                    : "";
+                let content = "";
+                try {
+                    const parsed = JSON.parse(item.msg_content ?? "{}");
+                    const parsedText = parsed.text;
+                    if (parsedText?.content)
+                        content = parsedText.content;
+                    else if (parsed.image)
+                        content = "[图片]";
+                    else if (parsed.voice)
+                        content = "[语音]";
+                    else if (parsed.video)
+                        content = "[视频]";
+                    else if (parsed.file)
+                        content = "[文件]";
+                    else if (parsed.link) {
+                        const lk = parsed.link;
+                        const linkParts = [lk.title, lk.desc].filter(Boolean).join(" - ");
+                        const linkUrl = lk.url ?? "";
+                        content = `[链接: ${linkParts} ${linkUrl}]`.trim();
+                    }
+                    else if (parsed.location) {
+                        const loc = parsed.location;
+                        const locParts = [loc.name, loc.address].filter(Boolean).join(", ");
+                        const coords = loc.latitude != null && loc.longitude != null ? ` (${loc.latitude}, ${loc.longitude})` : "";
+                        content = locParts ? `[位置: ${locParts}${coords}]` : coords ? `[位置:${coords}]` : "[位置]";
+                    }
+                    else if (parsed.miniprogram) {
+                        const mp = parsed.miniprogram;
+                        content = `[小程序: ${mp.title ?? ""} (${mp.appid ?? ""})]`;
+                    }
+                    else if (parsed.channels) {
+                        const ch = parsed.channels;
+                        content = `[视频号: ${[ch.nickname, ch.title].filter(Boolean).join(" - ")}]`;
+                    }
+                    else
+                        content = `[${item.msgtype ?? parsed.msgtype ?? "未知类型"}]`;
+                }
+                catch {
+                    content = item.msg_content ?? "";
+                }
+                return `${sender}${timeStr}: ${content}`;
+            });
+            return `[转发的聊天记录: ${title}]\n${lines.join("\n")}`;
+        }
+        case "channels": {
+            const ch = msg.channels;
+            const typeMap = { 1: "视频号动态", 2: "视频号直播", 3: "视频号名片" };
+            const typeName = ch?.sub_type != null ? (typeMap[ch.sub_type] ?? "视频号消息") : "视频号消息";
+            return `[${typeName}] ${ch?.nickname ?? ""}: ${ch?.title ?? ""}`;
+        }
+        case "miniprogram": {
+            const mp = msg.miniprogram;
+            const mpParts = [`[小程序] ${mp?.title ?? ""} (appid: ${mp?.appid ?? ""})`];
+            if (mp?.pagepath)
+                mpParts.push(`pagepath: ${mp.pagepath}`);
+            if (mp?.thumb_media_id)
+                mpParts.push(`thumb_media_id: ${mp.thumb_media_id}`);
+            return mpParts.join(", ");
+        }
+        case "msgmenu": {
+            const menu = msg.msgmenu;
+            const head = menu?.head_content ?? "";
+            const menuItems = Array.isArray(menu?.list) ? menu.list.map((item) => item.content ?? item.id).join(", ") : "";
+            return head ? `${head} [选项: ${menuItems}]` : `[菜单消息: ${menuItems}]`;
+        }
+        case "business_card":
+            return `[名片] userid: ${msg.business_card?.userid ?? ""}`;
+        case "channels_shop_product": {
+            const p = msg.channels_shop_product;
+            const productParts = ["[视频号商品]"];
+            if (p?.title)
+                productParts.push(p.title);
+            if (p?.sales_price)
+                productParts.push(`价格: ${p.sales_price}`);
+            if (p?.shop_nickname)
+                productParts.push(`店铺: ${p.shop_nickname}`);
+            if (p?.product_id)
+                productParts.push(`商品ID: ${p.product_id}`);
+            if (p?.head_image)
+                productParts.push(`图片: ${p.head_image}`);
+            if (p?.shop_head_image)
+                productParts.push(`店铺头像: ${p.shop_head_image}`);
+            return productParts.join(" | ");
+        }
+        case "channels_shop_order": {
+            const o = msg.channels_shop_order;
+            const orderParts = ["[视频号订单]"];
+            if (o?.product_titles)
+                orderParts.push(o.product_titles);
+            if (o?.price_wording)
+                orderParts.push(`金额: ${o.price_wording}`);
+            if (o?.state)
+                orderParts.push(`状态: ${o.state}`);
+            if (o?.shop_nickname)
+                orderParts.push(`店铺: ${o.shop_nickname}`);
+            if (o?.order_id)
+                orderParts.push(`订单ID: ${o.order_id}`);
+            if (o?.image_url)
+                orderParts.push(`图片: ${o.image_url}`);
+            return orderParts.join(" | ");
+        }
+        case "note":
+            return "[用户发送了一条笔记]";
+        case "event":
+            return null;
+        default: {
+            const rawJson = JSON.stringify(msg, null, 2);
+            return `[未支持的消息类型: ${msg.msgtype}]\n\n原始JSON:\n${rawJson}`;
+        }
+    }
+}
+// ── Event handling ──
+/** Map known msg_send_fail fail_type codes to human-readable descriptions. */
+function failTypeLabel(failType) {
+    switch (failType) {
+        case 0:
+            return "unknown";
+        case 10:
+            return "user rejected";
+        case 13:
+            return "content security (phishing/scam pattern detected)";
+        default:
+            return "unrecognized";
+    }
+}
+async function handleEvent(ctx, _account, msg) {
+    const event = msg.event;
+    const { log } = ctx;
+    const kfId = msg.open_kfid;
+    switch (event?.event_type) {
+        case "enter_session":
+            log?.info(`${logTag(kfId)} user ${msg.external_userid} entered session` +
+                (event.welcome_code ? `, welcome_code=${event.welcome_code}` : "") +
+                (event.scene ? `, scene=${event.scene}` : ""));
+            break;
+        case "msg_send_fail":
+            log?.error(`${logTag(kfId)} message send failed: msgid=${event.fail_msgid}, type=${event.fail_type} (${failTypeLabel(event.fail_type)})`);
+            if (event.fail_type === 13) {
+                log?.warn?.(`${logTag(kfId)} content security block: avoid numbered lists (1. 2. 3.) when discussing passwords, API keys, or credentials. Use bullet points or conversational prose instead.`);
+            }
+            break;
+        case "servicer_status_change":
+            log?.info(`${logTag(kfId)} servicer status changed: ${event.servicer_userid} -> ${event.status}`);
+            break;
+        default:
+            log?.info(`${logTag(kfId)} unhandled event: ${event?.event_type}`);
+    }
+}
+// ── Cold Start Catch-up (Layer 1) ──
+// When there is no cursor (file missing, empty, corrupt), drain all pending
+// messages without dispatching them.  This prevents historical message
+// bombardment after cursor loss.
+async function drainToLatestCursor(corpId, appSecret, openKfId, syncToken, stateDir, log) {
+    let cursor = "";
+    let hasMore = true;
+    let totalDrained = 0;
+    while (hasMore) {
+        const syncReq = { limit: 1000, open_kfid: openKfId };
+        if (cursor)
+            syncReq.cursor = cursor;
+        else if (syncToken)
+            syncReq.token = syncToken;
+        let resp;
+        try {
+            resp = await syncMessages(corpId, appSecret, syncReq);
+        }
+        catch (err) {
+            log?.error(`${logTag(openKfId)} drain failed: ${formatError(err)}`);
+            return;
+        }
+        totalDrained += resp.msg_list?.length ?? 0;
+        if (resp.next_cursor) {
+            cursor = resp.next_cursor;
+            await saveCursor(stateDir, openKfId, cursor);
+        }
+        hasMore = resp.has_more === 1;
+    }
+    if (totalDrained > 0) {
+        log?.info(`${logTag(openKfId)} cold start catch-up: skipped ${totalDrained} messages, cursor saved`);
+    }
+}
+// ── Core message handler (per kfid) ──
+export async function handleWebhookEvent(ctx, openKfId, syncToken) {
+    // Acquire per-kfId mutex — chains onto any in-flight processing for this kfId
+    const prev = kfLocks.get(openKfId) ?? Promise.resolve();
+    let release;
+    const current = new Promise((r) => {
+        release = r;
+    });
+    kfLocks.set(openKfId, current);
+    try {
+        await prev;
+        await _handleWebhookEventInner(ctx, openKfId, syncToken);
+    }
+    finally {
+        release();
+        // Clean up map entry only if no newer caller has replaced it
+        if (kfLocks.get(openKfId) === current) {
+            kfLocks.delete(openKfId);
+        }
+    }
+}
+async function _handleWebhookEventInner(ctx, openKfId, syncToken) {
+    const { cfg, stateDir, log } = ctx;
+    const account = resolveAccount(cfg, openKfId); // kfid as accountId
+    const resolvedKfId = account.openKfId ?? openKfId; // recover original case
+    const { corpId, appSecret } = account;
+    if (!corpId || !appSecret) {
+        log?.error(`${logTag()} missing corpId/appSecret`);
+        return;
+    }
+    // Register this kfid as discovered
+    await registerKfId(resolvedKfId);
+    let cursor = await loadCursor(stateDir, openKfId);
+    // Layer 1: Cold Start Catch-up — no cursor means drain without dispatching
+    if (!cursor) {
+        log?.info(`${logTag(openKfId)} no cursor, draining to current position`);
+        await drainToLatestCursor(corpId, appSecret, openKfId, syncToken, stateDir, log);
+        return;
+    }
+    // Normal incremental pull — cursor is always present at this point
+    let hasMore = true;
+    while (hasMore) {
+        const syncReq = {
+            limit: 1000,
+            open_kfid: resolvedKfId, // Only pull messages for this kf account
+            cursor,
+        };
+        let resp;
+        try {
+            resp = await syncMessages(corpId, appSecret, syncReq);
+        }
+        catch (err) {
+            log?.error(`${logTag(openKfId)} sync_msg failed: ${formatError(err)}`);
+            return;
+        }
+        for (const msg of resp.msg_list ?? []) {
+            log?.debug?.(`${logTag(openKfId)} raw_msg ${msg.msgid} type=${msg.msgtype}: ${JSON.stringify(msg)}`);
+            // Handle event messages (any origin) before normal message processing
+            if (msg.msgtype === "event") {
+                await handleEvent(ctx, account, msg);
+                continue;
+            }
+            if (msg.origin !== 3) {
+                log?.debug?.(`${logTag(openKfId)} skipping non-customer msg ${msg.msgid} (origin=${msg.origin})`);
+                continue;
+            }
+            // Layer 2: skip stale messages to prevent bombardment from corrupt cursors
+            const messageAgeS = Math.floor(Date.now() / 1000) - msg.send_time;
+            if (messageAgeS > MAX_MESSAGE_AGE_S) {
+                log?.debug?.(`${logTag(openKfId)} skipping stale msg ${msg.msgid} (age=${messageAgeS}s)`);
+                continue;
+            }
+            // Dedup: skip messages we have already processed
+            if (isDuplicate(msg.msgid)) {
+                log?.debug?.(`${logTag(openKfId)} skipping duplicate msg ${msg.msgid}`);
+                continue;
+            }
+            const text = extractText(msg);
+            if (text === null || text === "") {
+                log?.debug?.(`${logTag(openKfId)} skipping empty text for msg ${msg.msgid} (type=${msg.msgtype})`);
+                continue;
+            }
+            try {
+                const prepared = await prepareMessage(ctx, account, msg, text);
+                if (prepared) {
+                    await getOrCreateDebouncer(ctx).enqueue(prepared);
+                }
+            }
+            catch (err) {
+                log?.error(`${logTag(openKfId)} dispatch error for msg ${msg.msgid}: ${formatError(err)}`);
+            }
+        }
+        // P1-02: Save cursor AFTER all messages in the batch are processed
+        // (at-least-once delivery). If the process crashes mid-batch, the
+        // cursor has not advanced and the batch will be re-pulled on restart.
+        // P1-01 msgid dedup ensures replayed messages are not dispatched twice.
+        if (resp.next_cursor) {
+            cursor = resp.next_cursor;
+            await saveCursor(stateDir, openKfId, cursor);
+        }
+        hasMore = resp.has_more === 1;
+    }
+}
+// ── Prepare + dispatch message to agent ──
+async function prepareMessage(ctx, account, msg, text) {
+    const { cfg, log } = ctx;
+    // ── DM policy check ──
+    const channelConfig = getChannelConfig(cfg);
+    const dmPolicy = channelConfig.dmPolicy ?? "open";
+    const externalUserId = msg.external_userid;
+    if (dmPolicy === "disabled") {
+        log?.info(`${logTag()} drop DM (dmPolicy: disabled)`);
+        return null;
+    }
+    const core = getRuntime();
+    if (dmPolicy !== "open") {
+        const configAllowFrom = channelConfig.allowFrom ?? [];
+        const storeAllowFrom = await readAllowFromStoreCompat(core, CHANNEL_ID, account.accountId);
+        const effectiveAllowFrom = [...configAllowFrom, ...storeAllowFrom];
+        const allowed = effectiveAllowFrom.includes(externalUserId);
+        if (!allowed) {
+            if (dmPolicy === "pairing") {
+                setPairingKfId(externalUserId, msg.open_kfid);
+                const { code, created } = await core.channel.pairing.upsertPairingRequest({
+                    channel: CHANNEL_ID,
+                    accountId: account.accountId,
+                    id: externalUserId,
+                    meta: { openKfId: msg.open_kfid },
+                });
+                if (created && account.corpId && account.appSecret) {
+                    log?.info(`${logTag()} pairing request sender=${externalUserId}`);
+                    try {
+                        await sendTextMessage(account.corpId, account.appSecret, externalUserId, msg.open_kfid, core.channel.pairing.buildPairingReply({
+                            channel: CHANNEL_ID,
+                            idLine: `Your WeChat KF external_userid: ${externalUserId}`,
+                            code,
+                        }));
+                    }
+                    catch (err) {
+                        log?.error(`${logTag()} pairing reply failed for ${externalUserId}: ${formatError(err)}`);
+                    }
+                }
+            }
+            else {
+                log?.info(`${logTag()} blocked sender ${externalUserId} (dmPolicy: ${dmPolicy})`);
+            }
+            return null;
+        }
+    }
+    const kfId = msg.open_kfid;
+    // Download media
+    const mediaPaths = [];
+    const mediaTypes = [];
+    if (account.corpId && account.appSecret) {
+        const mediaId = msg.image?.media_id || msg.voice?.media_id || msg.video?.media_id || msg.file?.media_id;
+        if (mediaId) {
+            try {
+                const { buffer, contentType } = await downloadMedia(account.corpId, account.appSecret, mediaId);
+                let mime;
+                let filename;
+                if (msg.msgtype === "image") {
+                    // Detect actual image format: magic bytes first, content-type fallback
+                    const detected = detectImageMime(buffer);
+                    if (detected) {
+                        mime = detected;
+                    }
+                    else {
+                        const ct = contentType.split(";")[0].trim();
+                        mime = ct.startsWith("image/") ? ct : "image/jpeg";
+                    }
+                    const ext = contentTypeToExt(mime) || ".jpg";
+                    filename = `wechat_image_${msg.msgid}${ext}`;
+                }
+                else {
+                    const staticMap = {
+                        voice: ["audio/amr", `wechat_voice_${msg.msgid}.amr`],
+                        video: ["video/mp4", `wechat_video_${msg.msgid}.mp4`],
+                        file: ["application/octet-stream", `wechat_file_${msg.msgid}`],
+                    };
+                    [mime, filename] = staticMap[msg.msgtype] ?? ["application/octet-stream", `wechat_media_${msg.msgid}`];
+                }
+                const saved = await core.channel.media.saveMediaBuffer(buffer, mime, "inbound", undefined, filename);
+                mediaPaths.push(saved.path);
+                mediaTypes.push(mime);
+                log?.info(`${logTag(kfId)} saved media: ${saved.path} (${mime})`);
+            }
+            catch (err) {
+                log?.error(`${logTag(kfId)} failed to save media ${mediaId}: ${formatError(err)}`);
+            }
+        }
+    }
+    // Download media from merged_msg items
+    if (msg.msgtype === "merged_msg" && msg.merged_msg?.item && account.corpId && account.appSecret) {
+        for (let idx = 0; idx < msg.merged_msg.item.length; idx++) {
+            const item = msg.merged_msg.item[idx];
+            try {
+                const parsed = JSON.parse(item.msg_content ?? "{}");
+                const itemMediaId = parsed.image?.media_id ||
+                    parsed.voice?.media_id ||
+                    parsed.video?.media_id ||
+                    parsed.file?.media_id;
+                if (!itemMediaId)
+                    continue;
+                const itemType = parsed.msgtype ?? item.msgtype ?? "media";
+                const { buffer, contentType } = await downloadMedia(account.corpId, account.appSecret, itemMediaId);
+                let mime;
+                let filename;
+                if (itemType === "image") {
+                    const detected = detectImageMime(buffer);
+                    if (detected) {
+                        mime = detected;
+                    }
+                    else {
+                        const ct = contentType.split(";")[0].trim();
+                        mime = ct.startsWith("image/") ? ct : "image/jpeg";
+                    }
+                    const ext = contentTypeToExt(mime) || ".jpg";
+                    filename = `wechat_merged_image_${msg.msgid}_${idx}${ext}`;
+                }
+                else {
+                    const staticMap = {
+                        voice: ["audio/amr", ".amr"],
+                        video: ["video/mp4", ".mp4"],
+                        file: ["application/octet-stream", ""],
+                    };
+                    const [m, ext] = staticMap[itemType] ?? ["application/octet-stream", ""];
+                    mime = m;
+                    filename = `wechat_merged_${itemType}_${msg.msgid}_${idx}${ext}`;
+                }
+                const saved = await core.channel.media.saveMediaBuffer(buffer, mime, "inbound", undefined, filename);
+                mediaPaths.push(saved.path);
+                mediaTypes.push(mime);
+                log?.info(`${logTag(kfId)} saved merged_msg media[${idx}]: ${saved.path} (${mime})`);
+            }
+            catch (err) {
+                log?.error(`${logTag(kfId)} failed to download merged_msg media item[${idx}]: ${formatError(err)}`);
+            }
+        }
+    }
+    return { ctx, account, msg, text, externalUserId, openKfId: kfId, mediaPaths, mediaTypes };
+}
+async function dispatchPrepared(prepared) {
+    const { ctx, msg, text, openKfId: kfId, mediaPaths, mediaTypes } = prepared;
+    const { cfg, runtime, log } = ctx;
+    const core = getRuntime();
+    const from = `${CHANNEL_ID}:${msg.external_userid}`;
+    const to = `user:${msg.external_userid}`;
+    // Route using kfid as accountId
+    const route = core.channel.routing.resolveAgentRoute({
+        cfg,
+        channel: CHANNEL_ID,
+        accountId: kfId,
+        peer: { kind: "direct", id: msg.external_userid },
+    });
+    // System event
+    const preview = text.replace(/\s+/g, " ").slice(0, 160);
+    core.system.enqueueSystemEvent(`WeChat-KF[${kfId}] DM from ${msg.external_userid}: ${preview}`, {
+        sessionKey: route.sessionKey,
+        contextKey: `${CHANNEL_ID}:message:${msg.msgid}`,
+    });
+    // Format envelope
+    const envelopeOptions = core.channel.reply.resolveEnvelopeFormatOptions(cfg);
+    const body = core.channel.reply.formatAgentEnvelope({
+        channel: "WeChat-KF",
+        from: msg.external_userid,
+        timestamp: new Date(msg.send_time * 1000),
+        envelope: envelopeOptions,
+        body: text,
+    });
+    // Build inbound context
+    const inboundCtx = core.channel.reply.finalizeInboundContext({
+        Body: body,
+        RawBody: text,
+        CommandBody: text,
+        From: from,
+        To: to,
+        SessionKey: route.sessionKey,
+        AccountId: kfId,
+        ChatType: "direct",
+        SenderName: msg.external_userid,
+        SenderId: msg.external_userid,
+        Provider: CHANNEL_ID,
+        Surface: CHANNEL_ID,
+        MessageSid: msg.msgid,
+        Timestamp: msg.send_time * 1000,
+        WasMentioned: false,
+        CommandAuthorized: true,
+        OriginatingChannel: CHANNEL_ID,
+        OriginatingTo: to,
+        MediaPaths: mediaPaths.length > 0 ? mediaPaths : undefined,
+        MediaTypes: mediaTypes.length > 0 ? mediaTypes : undefined,
+    });
+    // Dispatch to agent
+    const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcher({
+        cfg,
+        agentId: route.agentId,
+        runtime: runtime ?? {},
+        externalUserId: msg.external_userid,
+        openKfId: kfId,
+        accountId: kfId,
+    });
+    log?.info(`${logTag(kfId)} dispatching to agent (session=${route.sessionKey})`);
+    const { queuedFinal, counts } = await core.channel.reply.dispatchReplyFromConfig({
+        ctx: inboundCtx,
+        cfg,
+        dispatcher,
+        replyOptions,
+    });
+    markDispatchIdle?.();
+    log?.info(`${logTag(kfId)} dispatch complete (queuedFinal=${queuedFinal}, replies=${counts?.final})`);
+}
+async function dispatchCombined(items) {
+    const last = items[items.length - 1];
+    const combinedText = items
+        .map((i) => i.text)
+        .filter(Boolean)
+        .join("\n");
+    const combinedMediaPaths = items.flatMap((i) => i.mediaPaths);
+    const combinedMediaTypes = items.flatMap((i) => i.mediaTypes);
+    last.ctx.log?.info(`${logTag(last.openKfId)} coalescing ${items.length} messages from ${last.externalUserId}`);
+    const combined = {
+        ...last,
+        text: combinedText,
+        mediaPaths: combinedMediaPaths,
+        mediaTypes: combinedMediaTypes,
+    };
+    await dispatchPrepared(combined);
+}
+//# sourceMappingURL=bot.js.map