@poolzin/pool-bot 2026.2.21 → 2026.2.23

package/dist/slack/monitor/media.js

@@ -1,12 +1,6 @@
+import { normalizeHostname } from "../../infra/net/hostname.js";
 import { fetchRemoteMedia } from "../../media/fetch.js";
 import { saveMediaBuffer } from "../../media/store.js";
-function normalizeHostname(hostname) {
-    const normalized = hostname.trim().toLowerCase().replace(/\.$/, "");
-    if (normalized.startsWith("[") && normalized.endsWith("]")) {
-        return normalized.slice(1, -1);
-    }
-    return normalized;
-}
 function isSlackHostname(hostname) {
     const normalized = normalizeHostname(hostname);
     if (!normalized) {
@@ -94,12 +88,72 @@ export async function fetchWithSlackAuth(url, token) {
     // (Slack's CDN URLs are pre-signed and don't need it)
     return fetch(resolvedUrl.toString(), { redirect: "follow" });
 }
+/**
+ * Slack voice messages (audio clips, huddle recordings) carry a `subtype` of
+ * `"slack_audio"` but are served with a `video/*` MIME type (e.g. `video/mp4`,
+ * `video/webm`).  Override the primary type to `audio/` so the
+ * media-understanding pipeline routes them to transcription.
+ */
+function resolveSlackMediaMimetype(file, fetchedContentType) {
+    const mime = fetchedContentType ?? file.mimetype;
+    if (file.subtype === "slack_audio" && mime?.startsWith("video/")) {
+        return mime.replace("video/", "audio/");
+    }
+    return mime;
+}
+const MAX_SLACK_MEDIA_FILES = 8;
+const MAX_SLACK_MEDIA_CONCURRENCY = 3;
+const MAX_SLACK_FORWARDED_ATTACHMENTS = 8;
+function isForwardedSlackAttachment(attachment) {
+    // Narrow this parser to Slack's explicit "shared/forwarded" attachment payloads.
+    return attachment.is_share === true;
+}
+function resolveForwardedAttachmentImageUrl(attachment) {
+    const rawUrl = attachment.image_url?.trim();
+    if (!rawUrl) {
+        return null;
+    }
+    try {
+        const parsed = new URL(rawUrl);
+        if (parsed.protocol !== "https:" || !isSlackHostname(parsed.hostname)) {
+            return null;
+        }
+        return parsed.toString();
+    }
+    catch {
+        return null;
+    }
+}
+async function mapLimit(items, limit, fn) {
+    if (items.length === 0) {
+        return [];
+    }
+    const results = [];
+    results.length = items.length;
+    let nextIndex = 0;
+    const workerCount = Math.max(1, Math.min(limit, items.length));
+    await Promise.all(Array.from({ length: workerCount }, async () => {
+        while (true) {
+            const idx = nextIndex++;
+            if (idx >= items.length) {
+                return;
+            }
+            results[idx] = await fn(items[idx]);
+        }
+    }));
+    return results;
+}
+/**
+ * Downloads all files attached to a Slack message and returns them as an array.
+ * Returns `null` when no files could be downloaded.
+ */
 export async function resolveSlackMedia(params) {
     const files = params.files ?? [];
-    for (const file of files) {
+    const limitedFiles = files.length > MAX_SLACK_MEDIA_FILES ? files.slice(0, MAX_SLACK_MEDIA_FILES) : files;
+    const resolved = await mapLimit(limitedFiles, MAX_SLACK_MEDIA_CONCURRENCY, async (file) => {
         const url = file.url_private_download ?? file.url_private;
         if (!url) {
-            continue;
+            return null;
         }
         try {
             // Note: fetchRemoteMedia calls fetchImpl(url) with the URL string today and
@@ -113,28 +167,116 @@ export async function resolveSlackMedia(params) {
                 maxBytes: params.maxBytes,
             });
             if (fetched.buffer.byteLength > params.maxBytes) {
-                continue;
+                return null;
             }
-            const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType ?? file.mimetype, "inbound", params.maxBytes);
+            const effectiveMime = resolveSlackMediaMimetype(file, fetched.contentType);
+            const saved = await saveMediaBuffer(fetched.buffer, effectiveMime, "inbound", params.maxBytes);
             const label = fetched.fileName ?? file.name;
+            const contentType = effectiveMime ?? saved.contentType;
             return {
                 path: saved.path,
-                contentType: saved.contentType,
+                ...(contentType ? { contentType } : {}),
                 placeholder: label ? `[Slack file: ${label}]` : "[Slack file]",
             };
         }
         catch {
-            // Ignore download failures and fall through to the next file.
+            return null;
+        }
+    });
+    const results = resolved.filter((entry) => Boolean(entry));
+    return results.length > 0 ? results : null;
+}
+/** Extracts text and media from forwarded-message attachments. Returns null when empty. */
+export async function resolveSlackAttachmentContent(params) {
+    const attachments = params.attachments;
+    if (!attachments || attachments.length === 0) {
+        return null;
+    }
+    const forwardedAttachments = attachments
+        .filter((attachment) => isForwardedSlackAttachment(attachment))
+        .slice(0, MAX_SLACK_FORWARDED_ATTACHMENTS);
+    if (forwardedAttachments.length === 0) {
+        return null;
+    }
+    const textBlocks = [];
+    const allMedia = [];
+    for (const att of forwardedAttachments) {
+        const text = att.text?.trim() || att.fallback?.trim();
+        if (text) {
+            const author = att.author_name;
+            const heading = author ? `[Forwarded message from ${author}]` : "[Forwarded message]";
+            textBlocks.push(`${heading}\n${text}`);
+        }
+        const imageUrl = resolveForwardedAttachmentImageUrl(att);
+        if (imageUrl) {
+            try {
+                const fetched = await fetchRemoteMedia({
+                    url: imageUrl,
+                    maxBytes: params.maxBytes,
+                });
+                if (fetched.buffer.byteLength <= params.maxBytes) {
+                    const saved = await saveMediaBuffer(fetched.buffer, fetched.contentType, "inbound", params.maxBytes);
+                    const label = fetched.fileName ?? "forwarded image";
+                    allMedia.push({
+                        path: saved.path,
+                        contentType: fetched.contentType ?? saved.contentType,
+                        placeholder: `[Forwarded image: ${label}]`,
+                    });
+                }
+            }
+            catch {
+                // Skip images that fail to download
+            }
         }
+        if (att.files && att.files.length > 0) {
+            const fileMedia = await resolveSlackMedia({
+                files: att.files,
+                token: params.token,
+                maxBytes: params.maxBytes,
+            });
+            if (fileMedia) {
+                allMedia.push(...fileMedia);
+            }
+        }
+    }
+    const combinedText = textBlocks.join("\n\n");
+    if (!combinedText && allMedia.length === 0) {
+        return null;
     }
-    return null;
+    return { text: combinedText, media: allMedia };
 }
 const THREAD_STARTER_CACHE = new Map();
+const THREAD_STARTER_CACHE_TTL_MS = 6 * 60 * 60_000;
+const THREAD_STARTER_CACHE_MAX = 2000;
+function evictThreadStarterCache() {
+    const now = Date.now();
+    for (const [cacheKey, entry] of THREAD_STARTER_CACHE.entries()) {
+        if (now - entry.cachedAt > THREAD_STARTER_CACHE_TTL_MS) {
+            THREAD_STARTER_CACHE.delete(cacheKey);
+        }
+    }
+    if (THREAD_STARTER_CACHE.size <= THREAD_STARTER_CACHE_MAX) {
+        return;
+    }
+    const excess = THREAD_STARTER_CACHE.size - THREAD_STARTER_CACHE_MAX;
+    let removed = 0;
+    for (const cacheKey of THREAD_STARTER_CACHE.keys()) {
+        THREAD_STARTER_CACHE.delete(cacheKey);
+        removed += 1;
+        if (removed >= excess) {
+            break;
+        }
+    }
+}
 export async function resolveSlackThreadStarter(params) {
+    evictThreadStarterCache();
     const cacheKey = `${params.channelId}:${params.threadTs}`;
     const cached = THREAD_STARTER_CACHE.get(cacheKey);
+    if (cached && Date.now() - cached.cachedAt <= THREAD_STARTER_CACHE_TTL_MS) {
+        return cached.value;
+    }
     if (cached) {
-        return cached;
+        THREAD_STARTER_CACHE.delete(cacheKey);
     }
     try {
         const response = (await params.client.conversations.replies({
@@ -154,10 +296,76 @@ export async function resolveSlackThreadStarter(params) {
             ts: message.ts,
             files: message.files,
         };
-        THREAD_STARTER_CACHE.set(cacheKey, starter);
+        if (THREAD_STARTER_CACHE.has(cacheKey)) {
+            THREAD_STARTER_CACHE.delete(cacheKey);
+        }
+        THREAD_STARTER_CACHE.set(cacheKey, {
+            value: starter,
+            cachedAt: Date.now(),
+        });
+        evictThreadStarterCache();
         return starter;
     }
     catch {
         return null;
     }
 }
+export function resetSlackThreadStarterCacheForTest() {
+    THREAD_STARTER_CACHE.clear();
+}
+/**
+ * Fetches the most recent messages in a Slack thread (excluding the current message).
+ * Used to populate thread context when a new thread session starts.
+ *
+ * Uses cursor pagination and keeps only the latest N retained messages so long threads
+ * still produce up-to-date context without unbounded memory growth.
+ */
+export async function resolveSlackThreadHistory(params) {
+    const maxMessages = params.limit ?? 20;
+    if (!Number.isFinite(maxMessages) || maxMessages <= 0) {
+        return [];
+    }
+    // Slack recommends no more than 200 per page.
+    const fetchLimit = 200;
+    const retained = [];
+    let cursor;
+    try {
+        do {
+            const response = (await params.client.conversations.replies({
+                channel: params.channelId,
+                ts: params.threadTs,
+                limit: fetchLimit,
+                inclusive: true,
+                ...(cursor ? { cursor } : {}),
+            }));
+            for (const msg of response.messages ?? []) {
+                // Keep messages with text OR file attachments
+                if (!msg.text?.trim() && !msg.files?.length) {
+                    continue;
+                }
+                if (params.currentMessageTs && msg.ts === params.currentMessageTs) {
+                    continue;
+                }
+                retained.push(msg);
+                if (retained.length > maxMessages) {
+                    retained.shift();
+                }
+            }
+            const next = response.response_metadata?.next_cursor;
+            cursor = typeof next === "string" && next.trim().length > 0 ? next.trim() : undefined;
+        } while (cursor);
+        return retained.map((msg) => ({
+            // For file-only messages, create a placeholder showing attached filenames
+            text: msg.text?.trim()
+                ? msg.text
+                : `[attached: ${msg.files?.map((f) => f.name ?? "file").join(", ")}]`,
+            userId: msg.user,
+            botId: msg.bot_id,
+            ts: msg.ts,
+            files: msg.files,
+        }));
+    }
+    catch {
+        return [];
+    }
+}

package/dist/slack/monitor/message-handler/dispatch.js

@@ -1,16 +1,43 @@
 import { resolveHumanDelayConfig } from "../../../agents/identity.js";
 import { dispatchInboundMessage } from "../../../auto-reply/dispatch.js";
 import { clearHistoryEntriesIfEnabled } from "../../../auto-reply/reply/history.js";
+import { createReplyDispatcherWithTyping } from "../../../auto-reply/reply/reply-dispatcher.js";
 import { removeAckReactionAfterReply } from "../../../channels/ack-reactions.js";
 import { logAckFailure, logTypingFailure } from "../../../channels/logging.js";
-import { createReplyPrefixContext } from "../../../channels/reply-prefix.js";
+import { createReplyPrefixOptions } from "../../../channels/reply-prefix.js";
 import { createTypingCallbacks } from "../../../channels/typing.js";
-import { createReplyDispatcherWithTyping } from "../../../auto-reply/reply/reply-dispatcher.js";
 import { resolveStorePath, updateLastRoute } from "../../../config/sessions.js";
 import { danger, logVerbose, shouldLogVerbose } from "../../../globals.js";
 import { removeSlackReaction } from "../../actions.js";
+import { createSlackDraftStream } from "../../draft-stream.js";
+import { applyAppendOnlyStreamUpdate, buildStatusFinalPreviewText, resolveSlackStreamMode, } from "../../stream-mode.js";
+import { appendSlackStream, startSlackStream, stopSlackStream } from "../../streaming.js";
 import { resolveSlackThreadTargets } from "../../threading.js";
-import { createSlackReplyDeliveryPlan, deliverReplies } from "../replies.js";
+import { createSlackReplyDeliveryPlan, deliverReplies, resolveSlackThreadTs } from "../replies.js";
+function hasMedia(payload) {
+    return Boolean(payload.mediaUrl) || (payload.mediaUrls?.length ?? 0) > 0;
+}
+export function isSlackStreamingEnabled(streaming) {
+    return streaming !== false;
+}
+export function resolveSlackStreamingThreadHint(params) {
+    return resolveSlackThreadTs({
+        replyToMode: params.replyToMode,
+        incomingThreadTs: params.incomingThreadTs,
+        messageTs: params.messageTs,
+        hasReplied: false,
+    });
+}
+function shouldUseStreaming(params) {
+    if (!params.streamingEnabled) {
+        return false;
+    }
+    if (!params.threadTs) {
+        logVerbose("slack-stream: streaming disabled — no reply thread target available");
+        return false;
+    }
+    return true;
+}
 export async function dispatchPreparedSlackMessage(prepared) {
     const { ctx, account, message, route } = prepared;
     const cfg = ctx.cfg;
@@ -58,8 +85,9 @@ export async function dispatchPreparedSlackMessage(prepared) {
             });
         },
         stop: async () => {
-            if (!didSetStatus)
+            if (!didSetStatus) {
                 return;
+            }
             didSetStatus = false;
             await ctx.setSlackThreadStatus({
                 channelId: message.channel,
@@ -86,12 +114,129 @@ export async function dispatchPreparedSlackMessage(prepared) {
             });
         },
     });
-    const prefixContext = createReplyPrefixContext({ cfg, agentId: route.agentId });
+    const { onModelSelected, ...prefixOptions } = createReplyPrefixOptions({
+        cfg,
+        agentId: route.agentId,
+        channel: "slack",
+        accountId: route.accountId,
+    });
+    const streamingEnabled = isSlackStreamingEnabled(account.config.streaming);
+    const streamThreadHint = resolveSlackStreamingThreadHint({
+        replyToMode: ctx.replyToMode,
+        incomingThreadTs,
+        messageTs,
+    });
+    const useStreaming = shouldUseStreaming({
+        streamingEnabled,
+        threadTs: streamThreadHint,
+    });
+    let streamSession = null;
+    let streamFailed = false;
+    const deliverNormally = async (payload, forcedThreadTs) => {
+        const replyThreadTs = forcedThreadTs ?? replyPlan.nextThreadTs();
+        await deliverReplies({
+            replies: [payload],
+            target: prepared.replyTarget,
+            token: ctx.botToken,
+            accountId: account.accountId,
+            runtime,
+            textLimit: ctx.textLimit,
+            replyThreadTs,
+        });
+        replyPlan.markSent();
+    };
+    const deliverWithStreaming = async (payload) => {
+        if (streamFailed || hasMedia(payload) || !payload.text?.trim()) {
+            await deliverNormally(payload, streamSession?.threadTs);
+            return;
+        }
+        const text = payload.text.trim();
+        let plannedThreadTs;
+        try {
+            if (!streamSession) {
+                const streamThreadTs = replyPlan.nextThreadTs();
+                plannedThreadTs = streamThreadTs;
+                if (!streamThreadTs) {
+                    logVerbose("slack-stream: no reply thread target for stream start, falling back to normal delivery");
+                    streamFailed = true;
+                    await deliverNormally(payload);
+                    return;
+                }
+                streamSession = await startSlackStream({
+                    client: ctx.app.client,
+                    channel: message.channel,
+                    threadTs: streamThreadTs,
+                    text,
+                });
+                replyPlan.markSent();
+                return;
+            }
+            await appendSlackStream({
+                session: streamSession,
+                text: "\n" + text,
+            });
+        }
+        catch (err) {
+            runtime.error?.(danger(`slack-stream: streaming API call failed: ${String(err)}, falling back`));
+            streamFailed = true;
+            await deliverNormally(payload, streamSession?.threadTs ?? plannedThreadTs);
+        }
+    };
     const { dispatcher, replyOptions, markDispatchIdle } = createReplyDispatcherWithTyping({
-        responsePrefix: prefixContext.responsePrefix,
-        responsePrefixContextProvider: prefixContext.responsePrefixContextProvider,
+        ...prefixOptions,
         humanDelay: resolveHumanDelayConfig(cfg, route.agentId),
         deliver: async (payload) => {
+            if (useStreaming) {
+                await deliverWithStreaming(payload);
+                return;
+            }
+            const mediaCount = payload.mediaUrls?.length ?? (payload.mediaUrl ? 1 : 0);
+            const draftMessageId = draftStream?.messageId();
+            const draftChannelId = draftStream?.channelId();
+            const finalText = payload.text;
+            const canFinalizeViaPreviewEdit = streamMode !== "status_final" &&
+                mediaCount === 0 &&
+                !payload.isError &&
+                typeof finalText === "string" &&
+                finalText.trim().length > 0 &&
+                typeof draftMessageId === "string" &&
+                typeof draftChannelId === "string";
+            if (canFinalizeViaPreviewEdit) {
+                draftStream?.stop();
+                try {
+                    await ctx.app.client.chat.update({
+                        token: ctx.botToken,
+                        channel: draftChannelId,
+                        ts: draftMessageId,
+                        text: finalText.trim(),
+                    });
+                    return;
+                }
+                catch (err) {
+                    logVerbose(`slack: preview final edit failed; falling back to standard send (${String(err)})`);
+                }
+            }
+            else if (streamMode === "status_final" && hasStreamedMessage) {
+                try {
+                    const statusChannelId = draftStream?.channelId();
+                    const statusMessageId = draftStream?.messageId();
+                    if (statusChannelId && statusMessageId) {
+                        await ctx.app.client.chat.update({
+                            token: ctx.botToken,
+                            channel: statusChannelId,
+                            ts: statusMessageId,
+                            text: "Status: complete. Final answer posted below.",
+                        });
+                    }
+                }
+                catch (err) {
+                    logVerbose(`slack: status_final completion update failed (${String(err)})`);
+                }
+            }
+            else if (mediaCount > 0) {
+                await draftStream?.clear();
+                hasStreamedMessage = false;
+            }
             const replyThreadTs = replyPlan.nextThreadTs();
             await deliverReplies({
                 replies: [payload],
@@ -111,6 +256,53 @@ export async function dispatchPreparedSlackMessage(prepared) {
         onReplyStart: typingCallbacks.onReplyStart,
         onIdle: typingCallbacks.onIdle,
     });
+    const draftStream = createSlackDraftStream({
+        target: prepared.replyTarget,
+        token: ctx.botToken,
+        accountId: account.accountId,
+        maxChars: Math.min(ctx.textLimit, 4000),
+        resolveThreadTs: () => replyPlan.nextThreadTs(),
+        onMessageSent: () => replyPlan.markSent(),
+        log: logVerbose,
+        warn: logVerbose,
+    });
+    let hasStreamedMessage = false;
+    const streamMode = resolveSlackStreamMode(account.config.streamMode);
+    let appendRenderedText = "";
+    let appendSourceText = "";
+    let statusUpdateCount = 0;
+    const updateDraftFromPartial = (text) => {
+        const trimmed = text?.trimEnd();
+        if (!trimmed) {
+            return;
+        }
+        if (streamMode === "append") {
+            const next = applyAppendOnlyStreamUpdate({
+                incoming: trimmed,
+                rendered: appendRenderedText,
+                source: appendSourceText,
+            });
+            appendRenderedText = next.rendered;
+            appendSourceText = next.source;
+            if (!next.changed) {
+                return;
+            }
+            draftStream.update(next.rendered);
+            hasStreamedMessage = true;
+            return;
+        }
+        if (streamMode === "status_final") {
+            statusUpdateCount += 1;
+            if (statusUpdateCount > 1 && statusUpdateCount % 4 !== 0) {
+                return;
+            }
+            draftStream.update(buildStatusFinalPreviewText(statusUpdateCount));
+            hasStreamedMessage = true;
+            return;
+        }
+        draftStream.update(trimmed);
+        hasStreamedMessage = true;
+    };
     const { queuedFinal, counts } = await dispatchInboundMessage({
         ctx: prepared.ctxPayload,
         cfg,
@@ -119,17 +311,59 @@ export async function dispatchPreparedSlackMessage(prepared) {
             ...replyOptions,
             skillFilter: prepared.channelConfig?.skills,
             hasRepliedRef,
-            disableBlockStreaming: typeof account.config.blockStreaming === "boolean"
-                ? !account.config.blockStreaming
-                : undefined,
-            onModelSelected: (ctx) => {
-                prefixContext.onModelSelected(ctx);
-            },
+            disableBlockStreaming: useStreaming
+                ? false
+                : typeof account.config.blockStreaming === "boolean"
+                    ? !account.config.blockStreaming
+                    : undefined,
+            onModelSelected,
+            onPartialReply: useStreaming
+                ? undefined
+                : async (payload) => {
+                    updateDraftFromPartial(payload.text);
+                },
+            onAssistantMessageStart: useStreaming
+                ? undefined
+                : async () => {
+                    if (hasStreamedMessage) {
+                        draftStream.forceNewMessage();
+                        hasStreamedMessage = false;
+                        appendRenderedText = "";
+                        appendSourceText = "";
+                        statusUpdateCount = 0;
+                    }
+                },
+            onReasoningEnd: useStreaming
+                ? undefined
+                : async () => {
+                    if (hasStreamedMessage) {
+                        draftStream.forceNewMessage();
+                        hasStreamedMessage = false;
+                        appendRenderedText = "";
+                        appendSourceText = "";
+                        statusUpdateCount = 0;
+                    }
+                },
         },
     });
+    await draftStream.flush();
+    draftStream.stop();
     markDispatchIdle();
+    // -----------------------------------------------------------------------
+    // Finalize the stream if one was started
+    // -----------------------------------------------------------------------
+    const finalStream = streamSession;
+    if (finalStream && !finalStream.stopped) {
+        try {
+            await stopSlackStream({ session: finalStream });
+        }
+        catch (err) {
+            runtime.error?.(danger(`slack-stream: failed to stop stream: ${String(err)}`));
+        }
+    }
     const anyReplyDelivered = queuedFinal || (counts.block ?? 0) > 0 || (counts.final ?? 0) > 0;
     if (!anyReplyDelivered) {
+        await draftStream.clear();
         if (prepared.isRoomish) {
             clearHistoryEntriesIfEnabled({
                 historyMap: ctx.channelHistories,