multi-openim-channel 0.1.0

package/dist/inbound.js

@@ -0,0 +1,639 @@
+/**
+ * Inbound message dispatcher.
+ *
+ * Pipeline per message:
+ *   1. Filter (self-sent ignore, dedup, whitelist gating, group @-mention).
+ *   2. Extract a structured body (text + media items + quote unwrapping).
+ *   3. Optionally materialize image bytes for downstream multimodal agents.
+ *   4. Build a session key that always includes accountId for direct chats
+ *      so two accounts in the same conversation never collide.
+ *   5. Hand off to the host runtime's reply pipeline with a deliver()
+ *      callback that routes the agent reply back via the SDK.
+ */
+import { lookup } from "node:dns/promises";
+import { isIP } from "node:net";
+import { SessionType } from "@openim/client-sdk";
+import { sendTextToTarget } from "./media.js";
+import { parseTarget as parseChannelTarget } from "./targets.js";
+import { CHANNEL_ID } from "./types.js";
+import { formatSdkError, logTag } from "./utils.js";
+/* ---------------- dedup (per-account insertion-order LRU) ---------------- */
+const INBOUND_DEDUP_TTL_MS = 5 * 60 * 1000;
+const INBOUND_DEDUP_MAX_ENTRIES_PER_ACCOUNT = 4_096;
+const MAX_IMAGE_BYTES = 20 * 1024 * 1024;
+const MAX_TOTAL_INBOUND_IMAGE_BYTES = 40 * 1024 * 1024;
+const IMAGE_FETCH_TIMEOUT_MS = 8_000;
+/* ---------------- concurrency cap (per account) ---------------- */
+const MAX_INBOUND_INFLIGHT_PER_ACCOUNT = 16;
+const DROP_WARN_FLUSH_INTERVAL_MS = 30_000;
+const inflightByAccount = new Map();
+const dropAggByAccount = new Map();
+function noteInboundDrop(ctx, accountId) {
+    const now = Date.now();
+    let agg = dropAggByAccount.get(accountId);
+    if (!agg) {
+        agg = { count: 0, firstDropAt: now, lastFlushAt: 0 };
+        dropAggByAccount.set(accountId, agg);
+    }
+    if (agg.count === 0)
+        agg.firstDropAt = now;
+    agg.count++;
+    if (now - agg.lastFlushAt >= DROP_WARN_FLUSH_INTERVAL_MS) {
+        ctx.logger.warn?.(`${logTag("inbound")} rate-limited (account=${accountId} drops=${agg.count} since=${new Date(agg.firstDropAt).toISOString()})`);
+        agg.count = 0;
+        agg.lastFlushAt = now;
+    }
+}
+const inboundDedupByAccount = new Map();
+function getDedupBucket(accountId) {
+    let bucket = inboundDedupByAccount.get(accountId);
+    if (!bucket) {
+        bucket = new Map();
+        inboundDedupByAccount.set(accountId, bucket);
+    }
+    return bucket;
+}
+function shouldProcessInboundMessage(accountId, msg) {
+    const idPart = String(msg.clientMsgID || msg.serverMsgID || `${msg.sendID}-${msg.seq ?? msg.createTime ?? 0}`);
+    if (!idPart)
+        return true;
+    const bucket = getDedupBucket(accountId);
+    const now = Date.now();
+    const last = bucket.get(idPart);
+    if (last !== undefined) {
+        if (now - last < INBOUND_DEDUP_TTL_MS) {
+            bucket.delete(idPart);
+            bucket.set(idPart, now);
+            return false;
+        }
+        bucket.delete(idPart);
+    }
+    bucket.set(idPart, now);
+    if (bucket.size > INBOUND_DEDUP_MAX_ENTRIES_PER_ACCOUNT) {
+        const oldest = bucket.keys().next().value;
+        if (oldest !== undefined)
+            bucket.delete(oldest);
+    }
+    return true;
+}
+function shouldIgnoreSelfSentMessage(state, msg) {
+    const selfUserID = String(state.config.userID);
+    if (String(msg.sendID) !== selfUserID)
+        return false;
+    const isDirectSelfChat = msg.sessionType !== SessionType.Group && String(msg.recvID) === selfUserID;
+    if (!isDirectSelfChat)
+        return true;
+    const localPlatformID = Number(state.config.platformID);
+    const senderPlatformID = Number(msg.senderPlatformID);
+    if (!Number.isFinite(localPlatformID) || !Number.isFinite(senderPlatformID))
+        return true;
+    return localPlatformID === senderPlatformID;
+}
+function isGroupMessage(msg) {
+    return msg.sessionType === SessionType.Group && !!msg.groupID;
+}
+function isMentionedInGroup(msg, selfUserID) {
+    const list = msg.atTextElem?.atUserList;
+    if (!Array.isArray(list) || list.length === 0)
+        return false;
+    const id = String(selfUserID);
+    return list.some((item) => String(item) === id);
+}
+function normalizeSenderId(raw) {
+    const target = parseChannelTarget(raw);
+    if (!target)
+        return "";
+    return target.id.toLowerCase();
+}
+function isWhitelistedSender(state, msg) {
+    const whitelist = state.config.inboundWhitelist;
+    if (!Array.isArray(whitelist) || whitelist.length === 0)
+        return true;
+    const senderId = normalizeSenderId(msg.sendID);
+    if (!senderId)
+        return false;
+    return whitelist.some((id) => normalizeSenderId(id) === senderId);
+}
+function normalizeMimeType(value) {
+    const mime = String(value ?? "").trim().toLowerCase();
+    return mime.includes("/") ? mime : undefined;
+}
+function normalizeImageMimeType(value) {
+    const mime = String(value ?? "").trim().toLowerCase();
+    return mime.startsWith("image/") ? mime : undefined;
+}
+function normalizeString(value) {
+    const text = String(value ?? "").trim();
+    return text || undefined;
+}
+function normalizeSize(value) {
+    const n = typeof value === "number" ? value : Number(value);
+    return Number.isFinite(n) && n > 0 ? n : undefined;
+}
+function summarizeMedia(item) {
+    if (item.kind === "image")
+        return item.url ? `[Image] ${item.url}` : "[Image message]";
+    if (item.kind === "video") {
+        const parts = ["[Video]"];
+        if (item.fileName)
+            parts.push(`name=${item.fileName}`);
+        if (item.url)
+            parts.push(`video=${item.url}`);
+        if (item.snapshotUrl)
+            parts.push(`snapshot=${item.snapshotUrl}`);
+        if (item.size)
+            parts.push(`size=${item.size}`);
+        return parts.join(" ");
+    }
+    const parts = ["[File]"];
+    if (item.fileName)
+        parts.push(`name=${item.fileName}`);
+    if (item.mimeType)
+        parts.push(`type=${item.mimeType}`);
+    if (item.url)
+        parts.push(`url=${item.url}`);
+    if (item.size)
+        parts.push(`size=${item.size}`);
+    return parts.join(" ");
+}
+function extractPictureMedia(msg) {
+    const pic = msg.pictureElem;
+    if (!pic)
+        return [];
+    const url = normalizeString(pic.sourcePicture?.url) || normalizeString(pic.bigPicture?.url) || normalizeString(pic.snapshotPicture?.url);
+    const mimeType = normalizeImageMimeType(pic.sourcePicture?.type) ||
+        normalizeImageMimeType(pic.bigPicture?.type) ||
+        normalizeImageMimeType(pic.snapshotPicture?.type);
+    return [{ kind: "image", url, mimeType }];
+}
+function extractVideoMedia(msg) {
+    const video = msg.videoElem;
+    if (!video)
+        return [];
+    return [
+        {
+            kind: "video",
+            url: normalizeString(video.videoUrl),
+            snapshotUrl: normalizeString(video.snapshotUrl),
+            fileName: normalizeString(video.videoName ?? video.fileName ?? video.snapshotName),
+            size: normalizeSize(video.videoSize ?? video.duration),
+            mimeType: normalizeMimeType(video.videoType ?? video.type),
+        },
+    ];
+}
+function extractFileMedia(msg) {
+    const file = msg.fileElem;
+    if (!file)
+        return [];
+    return [
+        {
+            kind: "file",
+            url: normalizeString(file.sourceUrl),
+            fileName: normalizeString(file.fileName),
+            size: normalizeSize(file.fileSize),
+            mimeType: normalizeMimeType(file.fileType ?? file.type),
+        },
+    ];
+}
+function mergeBodyParts(parts) {
+    const valid = parts.filter((p) => p && (p.body || (p.media && p.media.length > 0)));
+    if (valid.length === 0)
+        return { body: "", kind: "unknown" };
+    const bodies = valid.map((p) => p.body).filter(Boolean);
+    const media = valid.flatMap((p) => p.media ?? []);
+    if (valid.length === 1) {
+        const only = valid[0];
+        if (!only)
+            return { body: "", kind: "unknown" };
+        return {
+            body: bodies[0] || "",
+            kind: only.kind,
+            media: media.length > 0 ? media : undefined,
+        };
+    }
+    return {
+        body: bodies.join("\n"),
+        kind: "mixed",
+        media: media.length > 0 ? media : undefined,
+    };
+}
+function extractInboundBody(msg, depth = 0) {
+    const text = String(msg.textElem?.content ??
+        msg.atTextElem?.text ??
+        "").trim();
+    const imageMedia = extractPictureMedia(msg);
+    const videoMedia = extractVideoMedia(msg);
+    const fileMedia = extractFileMedia(msg);
+    const quoteElem = msg.quoteElem;
+    if (quoteElem?.quoteMessage) {
+        const quoted = quoteElem.quoteMessage;
+        const quotedSender = String(quoted.senderNickname || quoted.sendID || "unknown");
+        const quotedBody = depth < 2
+            ? extractInboundBody(quoted, depth + 1)
+            : { body: "[quoted message]", kind: "mixed" };
+        const currentParts = [];
+        if (text)
+            currentParts.push(`Reply: ${text}`);
+        for (const item of [...imageMedia, ...videoMedia, ...fileMedia]) {
+            currentParts.push(`Reply attachment: ${summarizeMedia(item)}`);
+        }
+        const bodyLines = [`[Quote] ${quotedSender}: ${quotedBody.body || "[empty message]"}`];
+        if (currentParts.length > 0)
+            bodyLines.push(currentParts.join("\n"));
+        return {
+            body: bodyLines.join("\n"),
+            kind: currentParts.length > 0 ? "mixed" : quotedBody.kind,
+            media: [...imageMedia, ...videoMedia, ...fileMedia],
+        };
+    }
+    const parts = [];
+    if (text)
+        parts.push({ body: text, kind: "text" });
+    for (const item of imageMedia)
+        parts.push({ body: summarizeMedia(item), kind: "image", media: [item] });
+    for (const item of videoMedia)
+        parts.push({ body: summarizeMedia(item), kind: "video", media: [item] });
+    for (const item of fileMedia)
+        parts.push({ body: summarizeMedia(item), kind: "file", media: [item] });
+    const customElem = msg.customElem;
+    if (customElem?.data || customElem?.description || customElem?.extension) {
+        const txt = String(customElem.description ?? customElem.data ?? customElem.extension ?? "").trim() ||
+            "[Custom message]";
+        parts.push({ body: `[Custom message] ${txt}`, kind: "mixed" });
+    }
+    return mergeBodyParts(parts);
+}
+/**
+ * Reject URLs that resolve to private / link-local / loopback / metadata
+ * addresses. Inbound image URLs are peer-controlled, so without this guard
+ * a hostile sender could probe the host's internal network through the
+ * agent process.
+ */
+function isPrivateOrLinkLocalIp(addr) {
+    const v = isIP(addr);
+    if (v === 4) {
+        const parts = addr.split(".").map((x) => Number(x));
+        const a = parts[0] ?? 0;
+        const b = parts[1] ?? 0;
+        if (a === 0)
+            return true;
+        if (a === 10)
+            return true;
+        if (a === 127)
+            return true;
+        if (a === 169 && b === 254)
+            return true;
+        if (a === 172 && b >= 16 && b <= 31)
+            return true;
+        if (a === 192 && b === 168)
+            return true;
+        if (a === 100 && b >= 64 && b <= 127)
+            return true;
+        if (a >= 224)
+            return true;
+        return false;
+    }
+    if (v === 6) {
+        const lower = addr.toLowerCase();
+        if (lower === "::" || lower === "::1")
+            return true;
+        if (lower.startsWith("fe80:") || lower.startsWith("fe8") || lower.startsWith("fe9") || lower.startsWith("fea") || lower.startsWith("feb")) {
+            return true;
+        }
+        if (lower.startsWith("fc") || lower.startsWith("fd"))
+            return true;
+        if (lower.startsWith("ff"))
+            return true;
+        if (lower.startsWith("::ffff:")) {
+            const v4 = lower.slice("::ffff:".length);
+            if (isIP(v4) === 4)
+                return isPrivateOrLinkLocalIp(v4);
+        }
+        return false;
+    }
+    return false;
+}
+const DISALLOWED_HOSTNAMES = new Set([
+    "localhost",
+    "metadata",
+    "metadata.google.internal",
+    "instance-data",
+    "instance-data.ec2.internal",
+]);
+async function assertSafeImageUrl(url) {
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+        throw new Error(`disallowed protocol: ${url.protocol}`);
+    }
+    const host = url.hostname.toLowerCase();
+    if (!host)
+        throw new Error("empty hostname");
+    if (DISALLOWED_HOSTNAMES.has(host)) {
+        throw new Error(`disallowed hostname: ${host}`);
+    }
+    if (isIP(host)) {
+        if (isPrivateOrLinkLocalIp(host)) {
+            throw new Error(`disallowed IP: ${host}`);
+        }
+        return;
+    }
+    let resolved;
+    try {
+        resolved = await lookup(host, { all: true });
+    }
+    catch (e) {
+        throw new Error(`DNS lookup failed for ${host}: ${e.message}`);
+    }
+    for (const entry of resolved) {
+        if (isPrivateOrLinkLocalIp(entry.address)) {
+            throw new Error(`hostname ${host} resolves to disallowed IP ${entry.address}`);
+        }
+    }
+}
+async function readBodyWithCap(response, controller) {
+    const body = response.body;
+    if (!body)
+        throw new Error("response has no body");
+    const reader = body.getReader();
+    const chunks = [];
+    let total = 0;
+    try {
+        while (true) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (!value)
+                continue;
+            total += value.byteLength;
+            if (total > MAX_IMAGE_BYTES) {
+                controller.abort();
+                throw new Error(`image too large: ${total} bytes (cap ${MAX_IMAGE_BYTES})`);
+            }
+            chunks.push(value);
+        }
+    }
+    finally {
+        try {
+            reader.releaseLock();
+        }
+        catch {
+            // ignore: cancellation can leave the lock in an odd state
+        }
+    }
+    return Buffer.concat(chunks.map((c) => Buffer.from(c)), total);
+}
+async function fetchImageAsContentPart(url, hintedMime) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        throw new Error(`invalid image URL`);
+    }
+    await assertSafeImageUrl(parsed);
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), IMAGE_FETCH_TIMEOUT_MS);
+    let response;
+    try {
+        response = await fetch(parsed, { signal: controller.signal, redirect: "error" });
+    }
+    catch (e) {
+        if (controller.signal.aborted) {
+            throw new Error(`image fetch timeout after ${IMAGE_FETCH_TIMEOUT_MS}ms`);
+        }
+        throw e;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+    if (!response.ok) {
+        throw new Error(`image fetch failed: ${response.status} ${response.statusText}`);
+    }
+    const declaredLength = Number(response.headers.get("content-length") || 0);
+    if (Number.isFinite(declaredLength) && declaredLength > MAX_IMAGE_BYTES) {
+        throw new Error(`image too large: ${declaredLength} bytes (cap ${MAX_IMAGE_BYTES})`);
+    }
+    const buffer = await readBodyWithCap(response, controller);
+    const mimeType = normalizeImageMimeType(response.headers.get("content-type")) ??
+        normalizeImageMimeType(hintedMime) ??
+        "image/jpeg";
+    return {
+        type: "image",
+        data: buffer.toString("base64"),
+        mimeType,
+    };
+}
+async function materializeInboundMedia(media) {
+    if (!Array.isArray(media) || media.length === 0)
+        return { images: [], warnings: [] };
+    const images = [];
+    const warnings = [];
+    let totalBytes = 0;
+    for (const item of media) {
+        try {
+            const url = item.kind === "image" ? item.url : item.kind === "video" ? item.snapshotUrl : undefined;
+            if (!url)
+                continue;
+            const part = await fetchImageAsContentPart(url, item.mimeType);
+            const approxBytes = part.data.length;
+            if (totalBytes + approxBytes > MAX_TOTAL_INBOUND_IMAGE_BYTES) {
+                warnings.push(`${summarizeMedia(item)} => skipped (cumulative image bytes ${totalBytes + approxBytes} exceeds ${MAX_TOTAL_INBOUND_IMAGE_BYTES})`);
+                break;
+            }
+            totalBytes += approxBytes;
+            images.push(part);
+        }
+        catch (e) {
+            warnings.push(`${summarizeMedia(item)} => ${formatSdkError(e)}`);
+        }
+    }
+    return { images, warnings };
+}
+function getRuntime(api) {
+    const rt = api.runtime;
+    return rt && typeof rt === "object" ? rt : undefined;
+}
+function buildTextEnvelope(runtime, cfg, fromLabel, senderId, timestamp, bodyText, chatType) {
+    const reply = runtime?.channel?.reply;
+    if (!reply?.formatInboundEnvelope)
+        return bodyText;
+    const envelopeOptions = reply.resolveEnvelopeFormatOptions?.(cfg) ?? {};
+    const formatted = reply.formatInboundEnvelope({
+        channel: "Multi-OpenIM",
+        from: fromLabel,
+        timestamp,
+        body: bodyText,
+        chatType,
+        sender: { name: fromLabel, id: senderId },
+        envelope: envelopeOptions,
+    });
+    return typeof formatted === "string" && formatted ? formatted : bodyText;
+}
+async function sendReplyFromInbound(state, msg, text) {
+    const target = isGroupMessage(msg)
+        ? { kind: "group", id: String(msg.groupID) }
+        : { kind: "user", id: String(msg.sendID) };
+    await sendTextToTarget(state, target, text);
+}
+export async function processInboundMessage(ctx, state, msg) {
+    const aid = state.config.accountId;
+    const inflight = inflightByAccount.get(aid) ?? 0;
+    if (inflight >= MAX_INBOUND_INFLIGHT_PER_ACCOUNT) {
+        noteInboundDrop(ctx, aid);
+        return;
+    }
+    inflightByAccount.set(aid, inflight + 1);
+    try {
+        await processInboundMessageImpl(ctx, state, msg);
+    }
+    finally {
+        const n = inflightByAccount.get(aid) ?? 1;
+        if (n <= 1)
+            inflightByAccount.delete(aid);
+        else
+            inflightByAccount.set(aid, n - 1);
+    }
+}
+async function processInboundMessageImpl(ctx, state, msg) {
+    const api = ctx.api;
+    const runtime = getRuntime(api);
+    if (!runtime?.channel?.reply?.dispatchReplyWithBufferedBlockDispatcher) {
+        ctx.logger.warn?.(`${logTag("inbound")} runtime.channel.reply not available; skipping`);
+        return;
+    }
+    if (shouldIgnoreSelfSentMessage(state, msg))
+        return;
+    if (!shouldProcessInboundMessage(state.config.accountId, msg))
+        return;
+    const inbound = extractInboundBody(msg);
+    if (!inbound.body && (!inbound.media || inbound.media.length === 0)) {
+        ctx.logger.info?.(`${logTag("inbound")} skip unsupported msg: contentType=${msg.contentType} clientMsgID=${msg.clientMsgID || "unknown"}`);
+        return;
+    }
+    const group = isGroupMessage(msg);
+    const mentioned = group && isMentionedInGroup(msg, state.config.userID);
+    const hasWhitelist = state.config.inboundWhitelist.length > 0;
+    if (hasWhitelist) {
+        if (!isWhitelistedSender(state, msg))
+            return;
+        if (group && !mentioned)
+            return;
+    }
+    else if (group && state.config.requireMention && !mentioned) {
+        return;
+    }
+    const baseSessionKey = group
+        ? `${CHANNEL_ID}:group:${msg.groupID}`.toLowerCase()
+        : `${CHANNEL_ID}:${msg.sendID}:${state.config.accountId}`.toLowerCase();
+    const cfg = api.config;
+    const routing = runtime.channel.routing;
+    const route = routing?.resolveAgentRoute?.({
+        cfg,
+        sessionKey: baseSessionKey,
+        channel: CHANNEL_ID,
+        accountId: state.config.accountId,
+    }) ?? { agentId: "main", sessionKey: baseSessionKey };
+    const sessionKey = group
+        ? String(route?.sessionKey ?? baseSessionKey).trim() || baseSessionKey
+        : baseSessionKey;
+    const sessionRt = runtime.channel.session;
+    const sessionCfg = cfg?.session?.store;
+    const storePath = sessionRt?.resolveStorePath?.(sessionCfg, { agentId: route.agentId ?? "main" }) ?? "";
+    const chatType = group ? "group" : "direct";
+    const fromLabel = String(msg.senderNickname || msg.sendID);
+    const senderId = String(msg.sendID);
+    const timestamp = Number(msg.sendTime) || Date.now();
+    const mediaResult = await materializeInboundMedia(inbound.media);
+    const warningText = mediaResult.warnings.map((w) => `[Media fetch failed] ${w}`).join("\n");
+    const rawBody = warningText ? `${inbound.body}\n${warningText}` : inbound.body;
+    const body = buildTextEnvelope(runtime, cfg, fromLabel, senderId, timestamp, rawBody, chatType);
+    for (const w of mediaResult.warnings) {
+        ctx.logger.warn?.(`${logTag("inbound")} media fetch failed: ${w}`);
+    }
+    const ctxPayload = {
+        Body: body,
+        RawBody: rawBody,
+        From: group ? `${CHANNEL_ID}:group:${msg.groupID}` : `${CHANNEL_ID}:${msg.sendID}`,
+        To: `${CHANNEL_ID}:${state.config.userID}`,
+        SessionKey: sessionKey,
+        AccountId: state.config.accountId,
+        ChatType: chatType,
+        ConversationLabel: fromLabel,
+        SenderName: fromLabel,
+        SenderId: senderId,
+        Provider: CHANNEL_ID,
+        Surface: CHANNEL_ID,
+        MessageSid: msg.clientMsgID || `${CHANNEL_ID}-${Date.now()}`,
+        Timestamp: timestamp,
+        OriginatingChannel: CHANNEL_ID,
+        OriginatingTo: `${CHANNEL_ID}:${state.config.userID}`,
+        CommandAuthorized: true,
+        _multiOpenim: {
+            accountId: state.config.accountId,
+            isGroup: group,
+            senderId,
+            groupId: String(msg.groupID || ""),
+            messageKind: inbound.kind,
+            mediaCount: inbound.media?.length ?? 0,
+        },
+    };
+    if (sessionRt?.recordInboundSession) {
+        await sessionRt.recordInboundSession({
+            storePath,
+            sessionKey,
+            ctx: ctxPayload,
+            updateLastRoute: !group
+                ? {
+                    sessionKey,
+                    channel: CHANNEL_ID,
+                    to: String(msg.sendID),
+                    accountId: state.config.accountId,
+                }
+                : undefined,
+            onRecordError: (err) => ctx.logger.warn?.(`${logTag("inbound")} recordInboundSession: ${String(err)}`),
+        });
+    }
+    runtime.channel.activity?.record?.({
+        channel: CHANNEL_ID,
+        accountId: state.config.accountId,
+        direction: "inbound",
+    });
+    try {
+        await runtime.channel.reply.dispatchReplyWithBufferedBlockDispatcher({
+            ctx: ctxPayload,
+            cfg,
+            dispatcherOptions: {
+                deliver: async (payload) => {
+                    if (!payload.text)
+                        return;
+                    try {
+                        await sendReplyFromInbound(state, msg, payload.text);
+                    }
+                    catch (e) {
+                        ctx.logger.error?.(`${logTag("inbound")} deliver failed: ${formatSdkError(e)}`);
+                    }
+                },
+                onError: (err, info) => {
+                    ctx.logger.error?.(`${logTag("inbound")} ${info?.kind || "reply"} failed: ${String(err)}`);
+                },
+            },
+            replyOptions: {
+                disableBlockStreaming: true,
+                images: mediaResult.images,
+            },
+        });
+    }
+    catch (err) {
+        ctx.logger.error?.(`${logTag("inbound")} dispatch failed: ${formatSdkError(err)}`);
+        try {
+            await sendReplyFromInbound(state, msg, `Processing failed: ${formatSdkError(err).slice(0, 80)}`);
+        }
+        catch {
+            // ignore secondary send failures
+        }
+    }
+}
+export function _internal_clearInboundDedup() {
+    inboundDedupByAccount.clear();
+    inflightByAccount.clear();
+    dropAggByAccount.clear();
+}

package/dist/index.d.ts

@@ -0,0 +1,11 @@
+/**
+ * multi-openim-channel — OpenClaw plugin entry point.
+ *
+ * Wires up: SDK polyfills → register the channel descriptor → register
+ * lifecycle handlers on the channel object so OpenClaw's health-monitor
+ * can drive us → register MCP tools → register the setup CLI → register
+ * the long-running SDK service.
+ */
+import "./polyfills.js";
+import type { PluginApi } from "./types.js";
+export default function register(api: PluginApi): void;