@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/infra/outbound/deliver.js

@@ -2,33 +2,20 @@ import { chunkByParagraph, chunkMarkdownTextWithMode, resolveChunkMode, resolveT
 import { resolveChannelMediaMaxBytes } from "../../channels/plugins/media-limits.js";
 import { loadChannelOutboundAdapter } from "../../channels/plugins/outbound/load.js";
 import { resolveMarkdownTableMode } from "../../config/markdown-tables.js";
+import { appendAssistantMessageToSessionTranscript, resolveMirroredTranscriptText, } from "../../config/sessions.js";
+import { createInternalHookEvent, triggerInternalHook } from "../../hooks/internal-hooks.js";
+import { getAgentScopedMediaLocalRoots } from "../../media/local-roots.js";
+import { getGlobalHookRunner } from "../../plugins/hook-runner-global.js";
 import { markdownToSignalTextChunks } from "../../signal/format.js";
 import { sendMessageSignal } from "../../signal/send.js";
-import { appendAssistantMessageToSessionTranscript, resolveMirroredTranscriptText, } from "../../config/sessions.js";
+import { throwIfAborted } from "./abort.js";
+import { ackDelivery, enqueueDelivery, failDelivery } from "./delivery-queue.js";
 import { normalizeReplyPayloadsForDelivery } from "./payloads.js";
 export { normalizeOutboundPayloads } from "./payloads.js";
-function throwIfAborted(abortSignal) {
-    if (abortSignal?.aborted) {
-        throw new Error("Outbound delivery aborted");
-    }
-}
 // Channel docking: outbound delivery delegates to plugin.outbound adapters.
 async function createChannelHandler(params) {
     const outbound = await loadChannelOutboundAdapter(params.channel);
-    if (!outbound?.sendText || !outbound?.sendMedia) {
-        throw new Error(`Outbound not configured for channel: ${params.channel}`);
-    }
-    const handler = createPluginHandler({
-        outbound,
-        cfg: params.cfg,
-        channel: params.channel,
-        to: params.to,
-        accountId: params.accountId,
-        replyToId: params.replyToId,
-        threadId: params.threadId,
-        deps: params.deps,
-        gifPlayback: params.gifPlayback,
-    });
+    const handler = createPluginHandler({ ...params, outbound });
     if (!handler) {
         throw new Error(`Outbound not configured for channel: ${params.channel}`);
     }
@@ -36,59 +23,120 @@ async function createChannelHandler(params) {
 }
 function createPluginHandler(params) {
     const outbound = params.outbound;
-    if (!outbound?.sendText || !outbound?.sendMedia)
+    if (!outbound?.sendText || !outbound?.sendMedia) {
         return null;
+    }
+    const baseCtx = createChannelOutboundContextBase(params);
     const sendText = outbound.sendText;
     const sendMedia = outbound.sendMedia;
     const chunker = outbound.chunker ?? null;
     const chunkerMode = outbound.chunkerMode;
+    const resolveCtx = (overrides) => ({
+        ...baseCtx,
+        replyToId: overrides?.replyToId ?? baseCtx.replyToId,
+        threadId: overrides?.threadId ?? baseCtx.threadId,
+    });
     return {
         chunker,
         chunkerMode,
         textChunkLimit: outbound.textChunkLimit,
         sendPayload: outbound.sendPayload
-            ? async (payload) => outbound.sendPayload({
-                cfg: params.cfg,
-                to: params.to,
+            ? async (payload, overrides) => outbound.sendPayload({
+                ...resolveCtx(overrides),
                 text: payload.text ?? "",
                 mediaUrl: payload.mediaUrl,
-                accountId: params.accountId,
-                replyToId: params.replyToId,
-                threadId: params.threadId,
-                gifPlayback: params.gifPlayback,
-                deps: params.deps,
                 payload,
             })
             : undefined,
-        sendText: async (text) => sendText({
-            cfg: params.cfg,
-            to: params.to,
+        sendText: async (text, overrides) => sendText({
+            ...resolveCtx(overrides),
             text,
-            accountId: params.accountId,
-            replyToId: params.replyToId,
-            threadId: params.threadId,
-            gifPlayback: params.gifPlayback,
-            deps: params.deps,
         }),
-        sendMedia: async (caption, mediaUrl) => sendMedia({
-            cfg: params.cfg,
-            to: params.to,
+        sendMedia: async (caption, mediaUrl, overrides) => sendMedia({
+            ...resolveCtx(overrides),
             text: caption,
             mediaUrl,
-            accountId: params.accountId,
-            replyToId: params.replyToId,
-            threadId: params.threadId,
-            gifPlayback: params.gifPlayback,
-            deps: params.deps,
         }),
     };
 }
+function createChannelOutboundContextBase(params) {
+    return {
+        cfg: params.cfg,
+        to: params.to,
+        accountId: params.accountId,
+        replyToId: params.replyToId,
+        threadId: params.threadId,
+        identity: params.identity,
+        gifPlayback: params.gifPlayback,
+        deps: params.deps,
+        silent: params.silent,
+        mediaLocalRoots: params.mediaLocalRoots,
+    };
+}
+const isAbortError = (err) => err instanceof Error && err.name === "AbortError";
 export async function deliverOutboundPayloads(params) {
+    const { channel, to, payloads } = params;
+    // Write-ahead delivery queue: persist before sending, remove after success.
+    const queueId = params.skipQueue
+        ? null
+        : await enqueueDelivery({
+            channel,
+            to,
+            accountId: params.accountId,
+            payloads,
+            threadId: params.threadId,
+            replyToId: params.replyToId,
+            bestEffort: params.bestEffort,
+            gifPlayback: params.gifPlayback,
+            silent: params.silent,
+            mirror: params.mirror,
+        }).catch(() => null); // Best-effort — don't block delivery if queue write fails.
+    // Wrap onError to detect partial failures under bestEffort mode.
+    // When bestEffort is true, per-payload errors are caught and passed to onError
+    // without throwing — so the outer try/catch never fires. We track whether any
+    // payload failed so we can call failDelivery instead of ackDelivery.
+    let hadPartialFailure = false;
+    const wrappedParams = params.onError
+        ? {
+            ...params,
+            onError: (err, payload) => {
+                hadPartialFailure = true;
+                params.onError(err, payload);
+            },
+        }
+        : params;
+    try {
+        const results = await deliverOutboundPayloadsCore(wrappedParams);
+        if (queueId) {
+            if (hadPartialFailure) {
+                await failDelivery(queueId, "partial delivery failure (bestEffort)").catch(() => { });
+            }
+            else {
+                await ackDelivery(queueId).catch(() => { }); // Best-effort cleanup.
+            }
+        }
+        return results;
+    }
+    catch (err) {
+        if (queueId) {
+            if (isAbortError(err)) {
+                await ackDelivery(queueId).catch(() => { });
+            }
+            else {
+                await failDelivery(queueId, err instanceof Error ? err.message : String(err)).catch(() => { });
+            }
+        }
+        throw err;
+    }
+}
+/** Core delivery logic (extracted for queue wrapper). */
+async function deliverOutboundPayloadsCore(params) {
     const { cfg, channel, to, payloads } = params;
     const accountId = params.accountId;
     const deps = params.deps;
     const abortSignal = params.abortSignal;
     const sendSignal = params.deps?.sendSignal ?? sendMessageSignal;
+    const mediaLocalRoots = getAgentScopedMediaLocalRoots(cfg, params.agentId ?? params.mirror?.agentId);
     const results = [];
     const handler = await createChannelHandler({
         cfg,
@@ -98,7 +146,10 @@ export async function deliverOutboundPayloads(params) {
         accountId,
         replyToId: params.replyToId,
         threadId: params.threadId,
+        identity: params.identity,
         gifPlayback: params.gifPlayback,
+        silent: params.silent,
+        mediaLocalRoots,
     });
     const textLimit = handler.chunker
         ? resolveTextChunkLimit(cfg, channel, accountId, {
@@ -118,10 +169,10 @@ export async function deliverOutboundPayloads(params) {
             accountId,
         })
         : undefined;
-    const sendTextChunks = async (text) => {
+    const sendTextChunks = async (text, overrides) => {
         throwIfAborted(abortSignal);
         if (!handler.chunker || textLimit === undefined) {
-            results.push(await handler.sendText(text));
+            results.push(await handler.sendText(text, overrides));
             return;
         }
         if (chunkMode === "newline") {
@@ -129,15 +180,17 @@ export async function deliverOutboundPayloads(params) {
             const blockChunks = mode === "markdown"
                 ? chunkMarkdownTextWithMode(text, textLimit, "newline")
                 : chunkByParagraph(text, textLimit);
-            if (!blockChunks.length && text)
+            if (!blockChunks.length && text) {
                 blockChunks.push(text);
+            }
             for (const blockChunk of blockChunks) {
                 const chunks = handler.chunker(blockChunk, textLimit);
-                if (!chunks.length && blockChunk)
+                if (!chunks.length && blockChunk) {
                     chunks.push(blockChunk);
+                }
                 for (const chunk of chunks) {
                     throwIfAborted(abortSignal);
-                    results.push(await handler.sendText(chunk));
+                    results.push(await handler.sendText(chunk, overrides));
                 }
             }
             return;
@@ -145,7 +198,7 @@ export async function deliverOutboundPayloads(params) {
         const chunks = handler.chunker(text, textLimit);
         for (const chunk of chunks) {
             throwIfAborted(abortSignal);
-            results.push(await handler.sendText(chunk));
+            results.push(await handler.sendText(chunk, overrides));
         }
     };
     const sendSignalText = async (text, styles) => {
@@ -191,48 +244,161 @@ export async function deliverOutboundPayloads(params) {
                 accountId: accountId ?? undefined,
                 textMode: "plain",
                 textStyles: formatted.styles,
+                mediaLocalRoots,
             })),
         };
     };
-    const normalizedPayloads = normalizeReplyPayloadsForDelivery(payloads);
+    const normalizeWhatsAppPayload = (payload) => {
+        const hasMedia = Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+        const rawText = typeof payload.text === "string" ? payload.text : "";
+        const normalizedText = rawText.replace(/^(?:[ \t]*\r?\n)+/, "");
+        if (!normalizedText.trim()) {
+            if (!hasMedia) {
+                return null;
+            }
+            return {
+                ...payload,
+                text: "",
+            };
+        }
+        return {
+            ...payload,
+            text: normalizedText,
+        };
+    };
+    const normalizedPayloads = normalizeReplyPayloadsForDelivery(payloads).flatMap((payload) => {
+        if (channel !== "whatsapp") {
+            return [payload];
+        }
+        const normalized = normalizeWhatsAppPayload(payload);
+        return normalized ? [normalized] : [];
+    });
+    const hookRunner = getGlobalHookRunner();
+    const sessionKeyForInternalHooks = params.mirror?.sessionKey;
     for (const payload of normalizedPayloads) {
         const payloadSummary = {
             text: payload.text ?? "",
             mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []),
             channelData: payload.channelData,
         };
+        const emitMessageSent = (params) => {
+            if (hookRunner?.hasHooks("message_sent")) {
+                void hookRunner
+                    .runMessageSent({
+                    to,
+                    content: params.content,
+                    success: params.success,
+                    ...(params.error ? { error: params.error } : {}),
+                }, {
+                    channelId: channel,
+                    accountId: accountId ?? undefined,
+                    conversationId: to,
+                })
+                    .catch(() => { });
+            }
+            if (!sessionKeyForInternalHooks) {
+                return;
+            }
+            void triggerInternalHook(createInternalHookEvent("message", "sent", sessionKeyForInternalHooks, {
+                to,
+                content: params.content,
+                success: params.success,
+                ...(params.error ? { error: params.error } : {}),
+                channelId: channel,
+                accountId: accountId ?? undefined,
+                conversationId: to,
+                messageId: params.messageId,
+            })).catch(() => { });
+        };
         try {
             throwIfAborted(abortSignal);
+            // Run message_sending plugin hook (may modify content or cancel)
+            let effectivePayload = payload;
+            if (hookRunner?.hasHooks("message_sending")) {
+                try {
+                    const sendingResult = await hookRunner.runMessageSending({
+                        to,
+                        content: payloadSummary.text,
+                        metadata: { channel, accountId, mediaUrls: payloadSummary.mediaUrls },
+                    }, {
+                        channelId: channel,
+                        accountId: accountId ?? undefined,
+                    });
+                    if (sendingResult?.cancel) {
+                        continue;
+                    }
+                    if (sendingResult?.content != null) {
+                        effectivePayload = { ...payload, text: sendingResult.content };
+                        payloadSummary.text = sendingResult.content;
+                    }
+                }
+                catch {
+                    // Don't block delivery on hook failure
+                }
+            }
             params.onPayload?.(payloadSummary);
-            if (handler.sendPayload && payload.channelData) {
-                results.push(await handler.sendPayload(payload));
+            const sendOverrides = {
+                replyToId: effectivePayload.replyToId ?? params.replyToId ?? undefined,
+                threadId: params.threadId ?? undefined,
+            };
+            if (handler.sendPayload && effectivePayload.channelData) {
+                const delivery = await handler.sendPayload(effectivePayload, sendOverrides);
+                results.push(delivery);
+                emitMessageSent({
+                    success: true,
+                    content: payloadSummary.text,
+                    messageId: delivery.messageId,
+                });
                 continue;
             }
             if (payloadSummary.mediaUrls.length === 0) {
+                const beforeCount = results.length;
                 if (isSignalChannel) {
                     await sendSignalTextChunks(payloadSummary.text);
                 }
                 else {
-                    await sendTextChunks(payloadSummary.text);
+                    await sendTextChunks(payloadSummary.text, sendOverrides);
                 }
+                const messageId = results.at(-1)?.messageId;
+                emitMessageSent({
+                    success: results.length > beforeCount,
+                    content: payloadSummary.text,
+                    messageId,
+                });
                 continue;
             }
             let first = true;
+            let lastMessageId;
             for (const url of payloadSummary.mediaUrls) {
                 throwIfAborted(abortSignal);
                 const caption = first ? payloadSummary.text : "";
                 first = false;
                 if (isSignalChannel) {
-                    results.push(await sendSignalMedia(caption, url));
+                    const delivery = await sendSignalMedia(caption, url);
+                    results.push(delivery);
+                    lastMessageId = delivery.messageId;
                 }
                 else {
-                    results.push(await handler.sendMedia(caption, url));
+                    const delivery = await handler.sendMedia(caption, url, sendOverrides);
+                    results.push(delivery);
+                    lastMessageId = delivery.messageId;
                 }
             }
+            emitMessageSent({
+                success: true,
+                content: payloadSummary.text,
+                messageId: lastMessageId,
+            });
         }
         catch (err) {
-            if (!params.bestEffort)
+            emitMessageSent({
+                success: false,
+                content: payloadSummary.text,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            if (!params.bestEffort) {
                 throw err;
+            }
             params.onError?.(err, payloadSummary);
         }
     }

package/dist/infra/outbound/message-action-spec.js

@@ -42,12 +42,14 @@ export const MESSAGE_ACTION_TARGET_MODE = {
     "category-create": "none",
     "category-edit": "none",
     "category-delete": "none",
+    "topic-create": "to",
     "voice-status": "none",
     "event-list": "none",
     "event-create": "none",
     timeout: "none",
     kick: "none",
     ban: "none",
+    "set-presence": "none",
 };
 const ACTION_TARGET_ALIASES = {
     unsend: ["messageId"],
@@ -64,20 +66,25 @@ export function actionRequiresTarget(action) {
 }
 export function actionHasTarget(action, params) {
     const to = typeof params.to === "string" ? params.to.trim() : "";
-    if (to)
+    if (to) {
         return true;
+    }
     const channelId = typeof params.channelId === "string" ? params.channelId.trim() : "";
-    if (channelId)
+    if (channelId) {
         return true;
+    }
     const aliases = ACTION_TARGET_ALIASES[action];
-    if (!aliases)
+    if (!aliases) {
         return false;
+    }
     return aliases.some((alias) => {
         const value = params[alias];
-        if (typeof value === "string")
+        if (typeof value === "string") {
             return value.trim().length > 0;
-        if (typeof value === "number")
+        }
+        if (typeof value === "number") {
             return Number.isFinite(value);
+        }
         return false;
     });
 }

package/dist/infra/outbound/outbound-session.js

@@ -2,7 +2,7 @@ import { getChannelPlugin } from "../../channels/plugins/index.js";
 import { recordSessionMetaFromInbound, resolveStorePath } from "../../config/sessions.js";
 import { parseDiscordTarget } from "../../discord/targets.js";
 import { parseIMessageTarget, normalizeIMessageHandle } from "../../imessage/targets.js";
-import { buildAgentSessionKey, } from "../../routing/resolve-route.js";
+import { buildAgentSessionKey } from "../../routing/resolve-route.js";
 import { resolveThreadSessionKeys } from "../../routing/session-key.js";
 import { resolveSignalPeerId, resolveSignalRecipient, resolveSignalSender, } from "../../signal/identity.js";
 import { resolveSlackAccount } from "../../slack/accounts.js";
@@ -55,7 +55,7 @@ function stripKindPrefix(raw) {
 function inferPeerKind(params) {
     const resolvedKind = params.resolvedTarget?.kind;
     if (resolvedKind === "user") {
-        return "dm";
+        return "direct";
     }
     if (resolvedKind === "channel") {
         return "channel";
@@ -70,7 +70,7 @@ function inferPeerKind(params) {
         }
         return "group";
     }
-    return "dm";
+    return "direct";
 }
 function buildBaseSessionKey(params) {
     return buildAgentSessionKey({
@@ -138,7 +138,7 @@ async function resolveSlackSession(params) {
         return null;
     }
     const isDm = parsed.kind === "user";
-    let peerKind = isDm ? "dm" : "channel";
+    let peerKind = isDm ? "direct" : "channel";
     if (!isDm && /^G/i.test(parsed.id)) {
         // Slack mpim/group DMs share the G-prefix; detect to align session keys with inbound.
         const channelType = await resolveSlackChannelType({
@@ -150,7 +150,7 @@ async function resolveSlackSession(params) {
             peerKind = "group";
         }
         if (channelType === "dm") {
-            peerKind = "dm";
+            peerKind = "direct";
         }
     }
     const peer = {
@@ -173,13 +173,13 @@ async function resolveSlackSession(params) {
         sessionKey: threadKeys.sessionKey,
         baseSessionKey,
         peer,
-        chatType: peerKind === "dm" ? "direct" : "channel",
-        from: peerKind === "dm"
+        chatType: peerKind === "direct" ? "direct" : "channel",
+        from: peerKind === "direct"
             ? `slack:${parsed.id}`
             : peerKind === "group"
                 ? `slack:group:${parsed.id}`
                 : `slack:channel:${parsed.id}`,
-        to: peerKind === "dm" ? `user:${parsed.id}` : `channel:${parsed.id}`,
+        to: peerKind === "direct" ? `user:${parsed.id}` : `channel:${parsed.id}`,
         threadId,
     };
 }
@@ -190,7 +190,7 @@ function resolveDiscordSession(params) {
     }
     const isDm = parsed.kind === "user";
     const peer = {
-        kind: isDm ? "dm" : "channel",
+        kind: isDm ? "direct" : "channel",
         id: parsed.id,
     };
     const baseSessionKey = buildBaseSessionKey({
@@ -236,7 +236,7 @@ function resolveTelegramSession(params) {
             params.resolvedTarget.kind !== "user");
     const peerId = isGroup ? buildTelegramGroupPeerId(chatId, resolvedThreadId) : chatId;
     const peer = {
-        kind: isGroup ? "group" : "dm",
+        kind: isGroup ? "group" : "direct",
         id: peerId,
     };
     const baseSessionKey = buildBaseSessionKey({
@@ -263,7 +263,7 @@ function resolveWhatsAppSession(params) {
     }
     const isGroup = isWhatsAppGroupJid(normalized);
     const peer = {
-        kind: isGroup ? "group" : "dm",
+        kind: isGroup ? "group" : "direct",
         id: normalized,
     };
     const baseSessionKey = buildBaseSessionKey({
@@ -326,7 +326,7 @@ function resolveSignalSession(params) {
     });
     const peerId = sender ? resolveSignalPeerId(sender) : recipient;
     const displayRecipient = sender ? resolveSignalRecipient(sender) : recipient;
-    const peer = { kind: "dm", id: peerId };
+    const peer = { kind: "direct", id: peerId };
     const baseSessionKey = buildBaseSessionKey({
         cfg: params.cfg,
         agentId: params.agentId,
@@ -350,7 +350,7 @@ function resolveIMessageSession(params) {
         if (!handle) {
             return null;
         }
-        const peer = { kind: "dm", id: handle };
+        const peer = { kind: "direct", id: handle };
         const baseSessionKey = buildBaseSessionKey({
             cfg: params.cfg,
             agentId: params.agentId,
@@ -404,7 +404,7 @@ function resolveMatrixSession(params) {
     if (!rawId) {
         return null;
     }
-    const peer = { kind: isUser ? "dm" : "channel", id: rawId };
+    const peer = { kind: isUser ? "direct" : "channel", id: rawId };
     const baseSessionKey = buildBaseSessionKey({
         cfg: params.cfg,
         agentId: params.agentId,
@@ -436,7 +436,7 @@ function resolveMSTeamsSession(params) {
     const conversationId = rawId.split(";")[0] ?? rawId;
     const isChannel = !isUser && /@thread\.tacv2/i.test(conversationId);
     const peer = {
-        kind: isUser ? "dm" : isChannel ? "channel" : "group",
+        kind: isUser ? "direct" : isChannel ? "channel" : "group",
         id: conversationId,
     };
     const baseSessionKey = buildBaseSessionKey({
@@ -474,7 +474,7 @@ function resolveMattermostSession(params) {
     if (!rawId) {
         return null;
     }
-    const peer = { kind: isUser ? "dm" : "channel", id: rawId };
+    const peer = { kind: isUser ? "direct" : "channel", id: rawId };
     const baseSessionKey = buildBaseSessionKey({
         cfg: params.cfg,
         agentId: params.agentId,
@@ -515,7 +515,7 @@ function resolveBlueBubblesSession(params) {
         return null;
     }
     const peer = {
-        kind: isGroup ? "group" : "dm",
+        kind: isGroup ? "group" : "direct",
         id: peerId,
     };
     const baseSessionKey = buildBaseSessionKey({
@@ -570,7 +570,7 @@ function resolveZaloSession(params) {
     }
     const isGroup = trimmed.toLowerCase().startsWith("group:");
     const peerId = stripKindPrefix(trimmed);
-    const peer = { kind: isGroup ? "group" : "dm", id: peerId };
+    const peer = { kind: isGroup ? "group" : "direct", id: peerId };
     const baseSessionKey = buildBaseSessionKey({
         cfg: params.cfg,
         agentId: params.agentId,
@@ -597,7 +597,7 @@ function resolveZalouserSession(params) {
     const isGroup = trimmed.toLowerCase().startsWith("group:");
     const peerId = stripKindPrefix(trimmed);
     // Keep DM vs group aligned with inbound sessions for Zalo Personal.
-    const peer = { kind: isGroup ? "group" : "dm", id: peerId };
+    const peer = { kind: isGroup ? "group" : "direct", id: peerId };
     const baseSessionKey = buildBaseSessionKey({
         cfg: params.cfg,
         agentId: params.agentId,
@@ -619,7 +619,7 @@ function resolveNostrSession(params) {
     if (!trimmed) {
         return null;
     }
-    const peer = { kind: "dm", id: trimmed };
+    const peer = { kind: "direct", id: trimmed };
     const baseSessionKey = buildBaseSessionKey({
         cfg: params.cfg,
         agentId: params.agentId,
@@ -680,7 +680,7 @@ function resolveTlonSession(params) {
     else {
         peerId = normalizeTlonShip(trimmed);
     }
-    const peer = { kind: isGroup ? "group" : "dm", id: peerId };
+    const peer = { kind: isGroup ? "group" : "direct", id: peerId };
     const baseSessionKey = buildBaseSessionKey({
         cfg: params.cfg,
         agentId: params.agentId,
@@ -728,7 +728,7 @@ function resolveFeishuSession(params) {
         isGroup = false;
     }
     const peer = {
-        kind: isGroup ? "group" : "dm",
+        kind: isGroup ? "group" : "direct",
         id: trimmed,
     };
     const baseSessionKey = buildBaseSessionKey({
@@ -767,9 +767,11 @@ function resolveFallbackSession(params) {
         channel: params.channel,
         peer,
     });
-    const chatType = peerKind === "dm" ? "direct" : peerKind === "channel" ? "channel" : "group";
-    const from = peerKind === "dm" ? `${params.channel}:${peerId}` : `${params.channel}:${peerKind}:${peerId}`;
-    const toPrefix = peerKind === "dm" ? "user" : "channel";
+    const chatType = peerKind === "direct" ? "direct" : peerKind === "channel" ? "channel" : "group";
+    const from = peerKind === "direct"
+        ? `${params.channel}:${peerId}`
+        : `${params.channel}:${peerKind}:${peerId}`;
+    const toPrefix = peerKind === "direct" ? "user" : "channel";
     return {
         sessionKey: baseSessionKey,
         baseSessionKey,