@gguf/pigbot 0.0.1 → 0.0.3

package/dist/infra/fs-safe.js

@@ -0,0 +1,76 @@
+import { constants as fsConstants } from "node:fs";
+import fs from "node:fs/promises";
+import path from "node:path";
+export class SafeOpenError extends Error {
+    code;
+    constructor(code, message) {
+        super(message);
+        this.code = code;
+        this.name = "SafeOpenError";
+    }
+}
+const NOT_FOUND_CODES = new Set(["ENOENT", "ENOTDIR"]);
+const ensureTrailingSep = (value) => (value.endsWith(path.sep) ? value : value + path.sep);
+const isNodeError = (err) => Boolean(err && typeof err === "object" && "code" in err);
+const isNotFoundError = (err) => isNodeError(err) && typeof err.code === "string" && NOT_FOUND_CODES.has(err.code);
+const isSymlinkOpenError = (err) => isNodeError(err) && (err.code === "ELOOP" || err.code === "EINVAL" || err.code === "ENOTSUP");
+export async function openFileWithinRoot(params) {
+    let rootReal;
+    try {
+        rootReal = await fs.realpath(params.rootDir);
+    }
+    catch (err) {
+        if (isNotFoundError(err)) {
+            throw new SafeOpenError("not-found", "root dir not found");
+        }
+        throw err;
+    }
+    const rootWithSep = ensureTrailingSep(rootReal);
+    const resolved = path.resolve(rootWithSep, params.relativePath);
+    if (!resolved.startsWith(rootWithSep)) {
+        throw new SafeOpenError("invalid-path", "path escapes root");
+    }
+    const supportsNoFollow = process.platform !== "win32" && "O_NOFOLLOW" in fsConstants;
+    const flags = fsConstants.O_RDONLY | (supportsNoFollow ? fsConstants.O_NOFOLLOW : 0);
+    let handle;
+    try {
+        handle = await fs.open(resolved, flags);
+    }
+    catch (err) {
+        if (isNotFoundError(err)) {
+            throw new SafeOpenError("not-found", "file not found");
+        }
+        if (isSymlinkOpenError(err)) {
+            throw new SafeOpenError("invalid-path", "symlink open blocked");
+        }
+        throw err;
+    }
+    try {
+        const lstat = await fs.lstat(resolved).catch(() => null);
+        if (lstat?.isSymbolicLink()) {
+            throw new SafeOpenError("invalid-path", "symlink not allowed");
+        }
+        const realPath = await fs.realpath(resolved);
+        if (!realPath.startsWith(rootWithSep)) {
+            throw new SafeOpenError("invalid-path", "path escapes root");
+        }
+        const stat = await handle.stat();
+        if (!stat.isFile()) {
+            throw new SafeOpenError("invalid-path", "not a file");
+        }
+        const realStat = await fs.stat(realPath);
+        if (stat.ino !== realStat.ino || stat.dev !== realStat.dev) {
+            throw new SafeOpenError("invalid-path", "path mismatch");
+        }
+        return { handle, realPath, stat };
+    }
+    catch (err) {
+        await handle.close().catch(() => { });
+        if (err instanceof SafeOpenError)
+            throw err;
+        if (isNotFoundError(err)) {
+            throw new SafeOpenError("not-found", "file not found");
+        }
+        throw err;
+    }
+}

package/dist/infra/gateway-lock.js

@@ -2,7 +2,7 @@ import { createHash } from "node:crypto";
 import fs from "node:fs/promises";
 import fsSync from "node:fs";
 import path from "node:path";
-import { resolveConfigPath, resolveStateDir } from "../config/paths.js";
+import { resolveConfigPath, resolveGatewayLockDir, resolveStateDir } from "../config/paths.js";
 const DEFAULT_TIMEOUT_MS = 5000;
 const DEFAULT_POLL_INTERVAL_MS = 100;
 const DEFAULT_STALE_MS = 30_000;
@@ -50,7 +50,7 @@ function isGatewayArgv(args) {
         return true;
     }
     const exe = normalized[0] ?? "";
-    return exe.endsWith("/pigbot") || exe === "pigbot";
+    return exe.endsWith("/moltbot") || exe === "moltbot";
 }
 function readLinuxCmdline(pid) {
     try {
@@ -119,13 +119,14 @@ function resolveGatewayLockPath(env) {
     const stateDir = resolveStateDir(env);
     const configPath = resolveConfigPath(env, stateDir);
     const hash = createHash("sha1").update(configPath).digest("hex").slice(0, 8);
-    const lockPath = path.join(stateDir, `gateway.${hash}.lock`);
+    const lockDir = resolveGatewayLockDir();
+    const lockPath = path.join(lockDir, `gateway.${hash}.lock`);
     return { lockPath, configPath };
 }
 export async function acquireGatewayLock(opts = {}) {
     const env = opts.env ?? process.env;
     const allowInTests = opts.allowInTests === true;
-    if (env.PIGBOT_ALLOW_MULTI_GATEWAY === "1" ||
+    if (env.CLAWDBOT_ALLOW_MULTI_GATEWAY === "1" ||
         (!allowInTests && (env.VITEST || env.NODE_ENV === "test"))) {
         return null;
     }

package/dist/infra/heartbeat-visibility.js

@@ -3,8 +3,22 @@ const DEFAULT_VISIBILITY = {
     showAlerts: true, // Show content messages
     useIndicator: true, // Emit indicator events
 };
+/**
+ * Resolve heartbeat visibility settings for a channel.
+ * Supports both deliverable channels (telegram, signal, etc.) and webchat.
+ * For webchat, uses channels.defaults.heartbeat since webchat doesn't have per-channel config.
+ */
 export function resolveHeartbeatVisibility(params) {
     const { cfg, channel, accountId } = params;
+    // Webchat uses channel defaults only (no per-channel or per-account config)
+    if (channel === "webchat") {
+        const channelDefaults = cfg.channels?.defaults?.heartbeat;
+        return {
+            showOk: channelDefaults?.showOk ?? DEFAULT_VISIBILITY.showOk,
+            showAlerts: channelDefaults?.showAlerts ?? DEFAULT_VISIBILITY.showAlerts,
+            useIndicator: channelDefaults?.useIndicator ?? DEFAULT_VISIBILITY.useIndicator,
+        };
+    }
     // Layer 1: Global channel defaults
     const channelDefaults = cfg.channels?.defaults?.heartbeat;
     // Layer 2: Per-channel config (at channel root level)

package/dist/infra/heartbeat-wake.js

@@ -30,10 +30,10 @@ function schedule(coalesceMs) {
                 schedule(DEFAULT_RETRY_MS);
             }
         }
-        catch (err) {
+        catch {
+            // Error is already logged by the heartbeat runner; schedule a retry.
             pendingReason = reason ?? "retry";
             schedule(DEFAULT_RETRY_MS);
-            throw err;
         }
         finally {
             running = false;

package/dist/infra/machine-name.js

@@ -20,7 +20,7 @@ function fallbackHostName() {
     return (os
         .hostname()
         .replace(/\.local$/i, "")
-        .trim() || "pigbot");
+        .trim() || "moltbot");
 }
 export async function getMachineDisplayName() {
     if (cachedPromise)

package/dist/infra/{pigbot-root.js → moltbot-root.js}

@@ -1,6 +1,7 @@
 import fs from "node:fs/promises";
 import path from "node:path";
 import { fileURLToPath } from "node:url";
+const CORE_PACKAGE_NAMES = new Set(["moltbot", "moltbot"]);
 async function readPackageName(dir) {
     try {
         const raw = await fs.readFile(path.join(dir, "package.json"), "utf-8");
@@ -15,7 +16,7 @@ async function findPackageRoot(startDir, maxDepth = 12) {
     let current = path.resolve(startDir);
     for (let i = 0; i < maxDepth; i += 1) {
         const name = await readPackageName(current);
-        if (name === "pigbot")
+        if (name && CORE_PACKAGE_NAMES.has(name))
             return current;
         const parent = path.dirname(current);
         if (parent === current)
@@ -36,7 +37,7 @@ function candidateDirsFromArgv1(argv1) {
     }
     return candidates;
 }
-export async function resolvePigbotPackageRoot(opts) {
+export async function resolveMoltbotPackageRoot(opts) {
     const candidates = [];
     if (opts.moduleUrl) {
         candidates.push(path.dirname(fileURLToPath(opts.moduleUrl)));

package/dist/infra/net/ssrf.js

@@ -1,4 +1,6 @@
 import { lookup as dnsLookup } from "node:dns/promises";
+import { lookup as dnsLookupCb } from "node:dns";
+import { Agent } from "undici";
 export class SsrFBlockedError extends Error {
     constructor(message) {
         super(message);
@@ -100,7 +102,45 @@ export function isBlockedHostname(hostname) {
         normalized.endsWith(".local") ||
         normalized.endsWith(".internal"));
 }
-export async function assertPublicHostname(hostname, lookupFn = dnsLookup) {
+export function createPinnedLookup(params) {
+    const normalizedHost = normalizeHostname(params.hostname);
+    const fallback = params.fallback ?? dnsLookupCb;
+    const fallbackLookup = fallback;
+    const fallbackWithOptions = fallback;
+    const records = params.addresses.map((address) => ({
+        address,
+        family: address.includes(":") ? 6 : 4,
+    }));
+    let index = 0;
+    return ((host, options, callback) => {
+        const cb = typeof options === "function" ? options : callback;
+        if (!cb)
+            return;
+        const normalized = normalizeHostname(host);
+        if (!normalized || normalized !== normalizedHost) {
+            if (typeof options === "function" || options === undefined) {
+                return fallbackLookup(host, cb);
+            }
+            return fallbackWithOptions(host, options, cb);
+        }
+        const opts = typeof options === "object" && options !== null
+            ? options
+            : {};
+        const requestedFamily = typeof options === "number" ? options : typeof opts.family === "number" ? opts.family : 0;
+        const candidates = requestedFamily === 4 || requestedFamily === 6
+            ? records.filter((entry) => entry.family === requestedFamily)
+            : records;
+        const usable = candidates.length > 0 ? candidates : records;
+        if (opts.all) {
+            cb(null, usable);
+            return;
+        }
+        const chosen = usable[index % usable.length];
+        index += 1;
+        cb(null, chosen.address, chosen.family);
+    });
+}
+export async function resolvePinnedHostname(hostname, lookupFn = dnsLookup) {
     const normalized = normalizeHostname(hostname);
     if (!normalized) {
         throw new Error("Invalid hostname");
@@ -120,4 +160,40 @@ export async function assertPublicHostname(hostname, lookupFn = dnsLookup) {
             throw new SsrFBlockedError("Blocked: resolves to private/internal IP address");
         }
     }
+    const addresses = Array.from(new Set(results.map((entry) => entry.address)));
+    if (addresses.length === 0) {
+        throw new Error(`Unable to resolve hostname: ${hostname}`);
+    }
+    return {
+        hostname: normalized,
+        addresses,
+        lookup: createPinnedLookup({ hostname: normalized, addresses }),
+    };
+}
+export function createPinnedDispatcher(pinned) {
+    return new Agent({
+        connect: {
+            lookup: pinned.lookup,
+        },
+    });
+}
+export async function closeDispatcher(dispatcher) {
+    if (!dispatcher)
+        return;
+    const candidate = dispatcher;
+    try {
+        if (typeof candidate.close === "function") {
+            await candidate.close();
+            return;
+        }
+        if (typeof candidate.destroy === "function") {
+            candidate.destroy();
+        }
+    }
+    catch {
+        // ignore dispatcher cleanup errors
+    }
+}
+export async function assertPublicHostname(hostname, lookupFn = dnsLookup) {
+    await resolvePinnedHostname(hostname, lookupFn);
 }

package/dist/infra/node-shell.js

@@ -2,7 +2,7 @@ export function buildNodeShellCommand(command, platform) {
     const normalized = String(platform ?? "")
         .trim()
         .toLowerCase();
-    if (normalized.includes("win")) {
+    if (normalized.startsWith("win")) {
         return ["cmd.exe", "/d", "/s", "/c", command];
     }
     return ["/bin/sh", "-lc", command];

package/dist/infra/outbound/deliver.js

@@ -1,11 +1,11 @@
-import { chunkByNewline, chunkMarkdownTextWithMode, resolveChunkMode, resolveTextChunkLimit, } from "../../auto-reply/chunk.js";
+import { chunkByParagraph, chunkMarkdownTextWithMode, resolveChunkMode, resolveTextChunkLimit, } from "../../auto-reply/chunk.js";
 import { resolveChannelMediaMaxBytes } from "../../channels/plugins/media-limits.js";
 import { loadChannelOutboundAdapter } from "../../channels/plugins/outbound/load.js";
 import { resolveMarkdownTableMode } from "../../config/markdown-tables.js";
 import { markdownToSignalTextChunks } from "../../signal/format.js";
 import { sendMessageSignal } from "../../signal/send.js";
 import { appendAssistantMessageToSessionTranscript, resolveMirroredTranscriptText, } from "../../config/sessions.js";
-import { normalizeOutboundPayloads } from "./payloads.js";
+import { normalizeReplyPayloadsForDelivery } from "./payloads.js";
 export { normalizeOutboundPayloads } from "./payloads.js";
 function throwIfAborted(abortSignal) {
     if (abortSignal?.aborted) {
@@ -46,6 +46,20 @@ function createPluginHandler(params) {
         chunker,
         chunkerMode,
         textChunkLimit: outbound.textChunkLimit,
+        sendPayload: outbound.sendPayload
+            ? async (payload) => outbound.sendPayload({
+                cfg: params.cfg,
+                to: params.to,
+                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,
@@ -112,15 +126,15 @@ export async function deliverOutboundPayloads(params) {
         }
         if (chunkMode === "newline") {
             const mode = handler.chunkerMode ?? "text";
-            const lineChunks = mode === "markdown"
+            const blockChunks = mode === "markdown"
                 ? chunkMarkdownTextWithMode(text, textLimit, "newline")
-                : chunkByNewline(text, textLimit, { splitLongLines: false });
-            if (!lineChunks.length && text)
-                lineChunks.push(text);
-            for (const lineChunk of lineChunks) {
-                const chunks = handler.chunker(lineChunk, textLimit);
-                if (!chunks.length && lineChunk)
-                    chunks.push(lineChunk);
+                : chunkByParagraph(text, textLimit);
+            if (!blockChunks.length && text)
+                blockChunks.push(text);
+            for (const blockChunk of blockChunks) {
+                const chunks = handler.chunker(blockChunk, textLimit);
+                if (!chunks.length && blockChunk)
+                    chunks.push(blockChunk);
                 for (const chunk of chunks) {
                     throwIfAborted(abortSignal);
                     results.push(await handler.sendText(chunk));
@@ -180,24 +194,33 @@ export async function deliverOutboundPayloads(params) {
             })),
         };
     };
-    const normalizedPayloads = normalizeOutboundPayloads(payloads);
+    const normalizedPayloads = normalizeReplyPayloadsForDelivery(payloads);
     for (const payload of normalizedPayloads) {
+        const payloadSummary = {
+            text: payload.text ?? "",
+            mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []),
+            channelData: payload.channelData,
+        };
         try {
             throwIfAborted(abortSignal);
-            params.onPayload?.(payload);
-            if (payload.mediaUrls.length === 0) {
+            params.onPayload?.(payloadSummary);
+            if (handler.sendPayload && payload.channelData) {
+                results.push(await handler.sendPayload(payload));
+                continue;
+            }
+            if (payloadSummary.mediaUrls.length === 0) {
                 if (isSignalChannel) {
-                    await sendSignalTextChunks(payload.text);
+                    await sendSignalTextChunks(payloadSummary.text);
                 }
                 else {
-                    await sendTextChunks(payload.text);
+                    await sendTextChunks(payloadSummary.text);
                 }
                 continue;
             }
             let first = true;
-            for (const url of payload.mediaUrls) {
+            for (const url of payloadSummary.mediaUrls) {
                 throwIfAborted(abortSignal);
-                const caption = first ? payload.text : "";
+                const caption = first ? payloadSummary.text : "";
                 first = false;
                 if (isSignalChannel) {
                     results.push(await sendSignalMedia(caption, url));
@@ -210,7 +233,7 @@ export async function deliverOutboundPayloads(params) {
         catch (err) {
             if (!params.bestEffort)
                 throw err;
-            params.onError?.(err, payload);
+            params.onError?.(err, payloadSummary);
         }
     }
     if (params.mirror && results.length > 0) {

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

@@ -349,6 +349,7 @@ function resolveGateway(input) {
     };
 }
 async function handleBroadcastAction(input, params) {
+    throwIfAborted(input.abortSignal);
     const broadcastEnabled = input.cfg.tools?.message?.broadcast?.enabled !== false;
     if (!broadcastEnabled) {
         throw new Error("Broadcast is disabled. Set tools.message.broadcast.enabled to true.");
@@ -366,8 +367,11 @@ async function handleBroadcastAction(input, params) {
         ? [await resolveChannel(input.cfg, { channel: channelHint })]
         : configured;
     const results = [];
+    const isAbortError = (err) => err instanceof Error && err.name === "AbortError";
     for (const targetChannel of targetChannels) {
+        throwIfAborted(input.abortSignal);
         for (const target of rawTargets) {
+            throwIfAborted(input.abortSignal);
             try {
                 const resolved = await resolveChannelTarget({
                     cfg: input.cfg,
@@ -393,6 +397,8 @@ async function handleBroadcastAction(input, params) {
                 });
             }
             catch (err) {
+                if (isAbortError(err))
+                    throw err;
                 results.push({
                     channel: targetChannel,
                     to: target,
@@ -411,8 +417,16 @@ async function handleBroadcastAction(input, params) {
         dryRun: Boolean(input.dryRun),
     };
 }
+function throwIfAborted(abortSignal) {
+    if (abortSignal?.aborted) {
+        const err = new Error("Message send aborted");
+        err.name = "AbortError";
+        throw err;
+    }
+}
 async function handleSendAction(ctx) {
-    const { cfg, params, channel, accountId, dryRun, gateway, input, agentId, resolvedTarget } = ctx;
+    const { cfg, params, channel, accountId, dryRun, gateway, input, agentId, resolvedTarget, abortSignal, } = ctx;
+    throwIfAborted(abortSignal);
     const action = "send";
     const to = readStringParam(params, "to", { required: true });
     // Support media, path, and filePath parameters for attachments
@@ -490,6 +504,7 @@ async function handleSendAction(ctx) {
         });
     }
     const mirrorMediaUrls = mergedMediaUrls.length > 0 ? mergedMediaUrls : mediaUrl ? [mediaUrl] : undefined;
+    throwIfAborted(abortSignal);
     const send = await executeSendAction({
         ctx: {
             cfg,
@@ -508,6 +523,7 @@ async function handleSendAction(ctx) {
                     mediaUrls: mirrorMediaUrls,
                 }
                 : undefined,
+            abortSignal,
         },
         to,
         message,
@@ -529,7 +545,8 @@ async function handleSendAction(ctx) {
     };
 }
 async function handlePollAction(ctx) {
-    const { cfg, params, channel, accountId, dryRun, gateway, input } = ctx;
+    const { cfg, params, channel, accountId, dryRun, gateway, input, abortSignal } = ctx;
+    throwIfAborted(abortSignal);
     const action = "poll";
     const to = readStringParam(params, "to", { required: true });
     const question = readStringParam(params, "pollQuestion", {
@@ -585,7 +602,8 @@ async function handlePollAction(ctx) {
     };
 }
 async function handlePluginAction(ctx) {
-    const { cfg, params, channel, accountId, dryRun, gateway, input } = ctx;
+    const { cfg, params, channel, accountId, dryRun, gateway, input, abortSignal } = ctx;
+    throwIfAborted(abortSignal);
     const action = input.action;
     if (dryRun) {
         return {
@@ -720,6 +738,7 @@ export async function runMessageAction(input) {
             input,
             agentId: resolvedAgentId,
             resolvedTarget,
+            abortSignal: input.abortSignal,
         });
     }
     if (action === "poll") {
@@ -731,6 +750,7 @@ export async function runMessageAction(input) {
             dryRun,
             gateway,
             input,
+            abortSignal: input.abortSignal,
         });
     }
     return handlePluginAction({
@@ -741,5 +761,6 @@ export async function runMessageAction(input) {
         dryRun,
         gateway,
         input,
+        abortSignal: input.abortSignal,
     });
 }

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

@@ -25,6 +25,7 @@ export const MESSAGE_ACTION_TARGET_MODE = {
     "thread-reply": "to",
     search: "none",
     sticker: "to",
+    "sticker-search": "none",
     "member-info": "none",
     "role-info": "none",
     "emoji-list": "none",

package/dist/infra/outbound/message.js

@@ -75,6 +75,7 @@ export async function sendMessage(params) {
             gifPlayback: params.gifPlayback,
             deps: params.deps,
             bestEffort: params.bestEffort,
+            abortSignal: params.abortSignal,
             mirror: params.mirror
                 ? {
                     ...params.mirror,

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

@@ -79,6 +79,9 @@ export function enforceCrossContextPolicy(params) {
 export async function buildCrossContextDecoration(params) {
     if (!params.toolContext?.currentChannelId)
         return null;
+    // Skip decoration for direct tool sends (agent composing, not forwarding)
+    if (params.toolContext.skipCrossContextDecoration)
+        return null;
     if (!isCrossContextTarget(params))
         return null;
     const markerConfig = params.cfg.tools?.message?.crossContext?.marker;
@@ -90,11 +93,11 @@ export async function buildCrossContextDecoration(params) {
         targetId: params.toolContext.currentChannelId,
         accountId: params.accountId ?? undefined,
     })) ?? params.toolContext.currentChannelId;
+    // Don't force group formatting here; currentChannelId can be a DM or a group.
     const originLabel = formatTargetDisplay({
         channel: params.channel,
         target: params.toolContext.currentChannelId,
         display: currentName,
-        kind: "group",
     });
     const prefixTemplate = markerConfig?.prefix ?? "[from {channel}] ";
     const suffixTemplate = markerConfig?.suffix ?? "";

package/dist/infra/outbound/outbound-send-service.js

@@ -21,7 +21,15 @@ function extractToolPayload(result) {
     }
     return result.content ?? result;
 }
+function throwIfAborted(abortSignal) {
+    if (abortSignal?.aborted) {
+        const err = new Error("Message send aborted");
+        err.name = "AbortError";
+        throw err;
+    }
+}
 export async function executeSendAction(params) {
+    throwIfAborted(params.ctx.abortSignal);
     if (!params.ctx.dryRun) {
         const handled = await dispatchChannelMessageAction({
             channel: params.ctx.channel,
@@ -53,6 +61,7 @@ export async function executeSendAction(params) {
             };
         }
     }
+    throwIfAborted(params.ctx.abortSignal);
     const result = await sendMessage({
         cfg: params.ctx.cfg,
         to: params.to,
@@ -67,6 +76,7 @@ export async function executeSendAction(params) {
         deps: params.ctx.deps,
         gateway: params.ctx.gateway,
         mirror: params.ctx.mirror,
+        abortSignal: params.ctx.abortSignal,
     });
     return {
         handledBy: "core",

package/dist/infra/outbound/payloads.js

@@ -45,17 +45,27 @@ export function normalizeReplyPayloadsForDelivery(payloads) {
 }
 export function normalizeOutboundPayloads(payloads) {
     return normalizeReplyPayloadsForDelivery(payloads)
-        .map((payload) => ({
-        text: payload.text ?? "",
-        mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []),
-    }))
-        .filter((payload) => payload.text || payload.mediaUrls.length > 0);
+        .map((payload) => {
+        const channelData = payload.channelData;
+        const normalized = {
+            text: payload.text ?? "",
+            mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : []),
+        };
+        if (channelData && Object.keys(channelData).length > 0) {
+            normalized.channelData = channelData;
+        }
+        return normalized;
+    })
+        .filter((payload) => payload.text ||
+        payload.mediaUrls.length > 0 ||
+        Boolean(payload.channelData && Object.keys(payload.channelData).length > 0));
 }
 export function normalizeOutboundPayloadsForJson(payloads) {
     return normalizeReplyPayloadsForDelivery(payloads).map((payload) => ({
         text: payload.text ?? "",
         mediaUrl: payload.mediaUrl ?? null,
         mediaUrls: payload.mediaUrls ?? (payload.mediaUrl ? [payload.mediaUrl] : undefined),
+        channelData: payload.channelData,
     }));
 }
 export function formatOutboundPayloadLog(payload) {