@poolzin/pool-bot 2026.2.21 → 2026.2.23

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

@@ -1,32 +1,34 @@
 import { resolveAckReaction } from "../../../agents/identity.js";
 import { hasControlCommand } from "../../../auto-reply/command-detection.js";
 import { shouldHandleTextCommands } from "../../../auto-reply/commands-registry.js";
-import { formatInboundEnvelope, formatThreadStarterEnvelope, resolveEnvelopeFormatOptions, } from "../../../auto-reply/envelope.js";
+import { formatInboundEnvelope, resolveEnvelopeFormatOptions, } from "../../../auto-reply/envelope.js";
 import { buildPendingHistoryContextFromMap, recordPendingHistoryEntryIfEnabled, } from "../../../auto-reply/reply/history.js";
 import { finalizeInboundContext } from "../../../auto-reply/reply/inbound-context.js";
 import { buildMentionRegexes, matchesMentionWithExplicit, } from "../../../auto-reply/reply/mentions.js";
+import { shouldAckReaction as shouldAckReactionGate, } from "../../../channels/ack-reactions.js";
+import { formatAllowlistMatchMeta } from "../../../channels/allowlist-match.js";
+import { resolveControlCommandGate } from "../../../channels/command-gating.js";
+import { resolveConversationLabel } from "../../../channels/conversation-label.js";
+import { logInboundDrop } from "../../../channels/logging.js";
+import { resolveMentionGatingWithBypass } from "../../../channels/mention-gating.js";
+import { recordInboundSession } from "../../../channels/session.js";
+import { readSessionUpdatedAt, resolveStorePath } from "../../../config/sessions.js";
 import { logVerbose, shouldLogVerbose } from "../../../globals.js";
 import { enqueueSystemEvent } from "../../../infra/system-events.js";
 import { buildPairingReply } from "../../../pairing/pairing-messages.js";
 import { upsertChannelPairingRequest } from "../../../pairing/pairing-store.js";
 import { resolveAgentRoute } from "../../../routing/resolve-route.js";
 import { resolveThreadSessionKeys } from "../../../routing/session-key.js";
-import { shouldAckReaction as shouldAckReactionGate, } from "../../../channels/ack-reactions.js";
-import { resolveMentionGatingWithBypass } from "../../../channels/mention-gating.js";
-import { resolveConversationLabel } from "../../../channels/conversation-label.js";
-import { resolveControlCommandGate } from "../../../channels/command-gating.js";
-import { logInboundDrop } from "../../../channels/logging.js";
-import { formatAllowlistMatchMeta } from "../../../channels/allowlist-match.js";
-import { recordInboundSession } from "../../../channels/session.js";
-import { readSessionUpdatedAt, resolveStorePath } from "../../../config/sessions.js";
 import { reactSlackMessage } from "../../actions.js";
 import { sendMessageSlack } from "../../send.js";
 import { resolveSlackThreadContext } from "../../threading.js";
 import { resolveSlackAllowListMatch, resolveSlackUserAllowed } from "../allow-list.js";
 import { resolveSlackEffectiveAllowFrom } from "../auth.js";
 import { resolveSlackChannelConfig } from "../channel-config.js";
+import { stripSlackMentionsForCommandDetection } from "../commands.js";
 import { normalizeSlackChannelType } from "../context.js";
-import { resolveSlackMedia, resolveSlackThreadStarter } from "../media.js";
+import { resolveSlackAttachmentContent, resolveSlackMedia, resolveSlackThreadHistory, resolveSlackThreadStarter, } from "../media.js";
+import { resolveSlackRoomContextHints } from "../room-context.js";
 export async function prepareSlackMessage(params) {
     const { ctx, account, message, opts } = params;
     const cfg = ctx.cfg;
@@ -56,8 +58,9 @@ export async function prepareSlackMessage(params) {
         false;
     const isBotMessage = Boolean(message.bot_id);
     if (isBotMessage) {
-        if (message.user && ctx.botUserId && message.user === ctx.botUserId)
+        if (message.user && ctx.botUserId && message.user === ctx.botUserId) {
             return null;
+        }
         if (!allowBots) {
             logVerbose(`slack: drop bot message ${message.bot_id ?? "unknown"} (allowBots=false)`);
             return null;
@@ -137,7 +140,7 @@ export async function prepareSlackMessage(params) {
         accountId: account.accountId,
         teamId: ctx.teamId || undefined,
         peer: {
-            kind: isDirectMessage ? "dm" : isRoom ? "channel" : "group",
+            kind: isDirectMessage ? "direct" : isRoom ? "channel" : "group",
             id: isDirectMessage ? (message.user ?? "unknown") : message.channel,
         },
     });
@@ -187,7 +190,9 @@ export async function prepareSlackMessage(params) {
         cfg,
         surface: "slack",
     });
-    const hasControlCommandInMessage = hasControlCommand(message.text ?? "", cfg);
+    // Strip Slack mentions (<@U123>) before command detection so "@Labrador /new" is recognized
+    const textForCommandDetection = stripSlackMentionsForCommandDetection(message.text ?? "");
+    const hasControlCommandInMessage = hasControlCommand(textForCommandDetection, cfg);
     const ownerAuthorized = resolveSlackAllowListMatch({
         allowList: allowFromLower,
         id: senderId,
@@ -266,10 +271,28 @@ export async function prepareSlackMessage(params) {
         token: ctx.botToken,
         maxBytes: ctx.mediaMaxBytes,
     });
-    const rawBody = (message.text ?? "").trim() || media?.placeholder || "";
-    if (!rawBody)
+    // Resolve forwarded message content (text + media) from Slack attachments
+    const attachmentContent = await resolveSlackAttachmentContent({
+        attachments: message.attachments,
+        token: ctx.botToken,
+        maxBytes: ctx.mediaMaxBytes,
+    });
+    // Merge forwarded media into the message's media array
+    const mergedMedia = [...(media ?? []), ...(attachmentContent?.media ?? [])];
+    const effectiveDirectMedia = mergedMedia.length > 0 ? mergedMedia : null;
+    const mediaPlaceholder = effectiveDirectMedia
+        ? effectiveDirectMedia.map((m) => m.placeholder).join(" ")
+        : undefined;
+    const rawBody = [(message.text ?? "").trim(), attachmentContent?.text, mediaPlaceholder]
+        .filter(Boolean)
+        .join("\n") || "";
+    if (!rawBody) {
         return null;
-    const ackReaction = resolveAckReaction(cfg, route.agentId);
+    }
+    const ackReaction = resolveAckReaction(cfg, route.agentId, {
+        channel: "slack",
+        accountId: account.accountId,
+    });
     const ackReactionValue = ackReaction ?? "";
     const shouldAckReaction = () => Boolean(ackReaction &&
         shouldAckReactionGate({
@@ -312,7 +335,10 @@ export async function prepareSlackMessage(params) {
         GroupSubject: isRoomish ? roomLabel : undefined,
         From: slackFrom,
     }) ?? (isDirectMessage ? senderName : roomLabel);
-    const textWithId = `${rawBody}\n[slack message id: ${message.ts} channel: ${message.channel}]`;
+    const threadInfo = isThreadReply && threadTs
+        ? ` thread_ts: ${threadTs}${message.parent_user_id ? ` parent_user_id: ${message.parent_user_id}` : ""}`
+        : "";
+    const textWithId = `${rawBody}\n[slack message id: ${message.ts} channel: ${message.channel}${threadInfo}]`;
     const storePath = resolveStorePath(ctx.cfg.session?.store, {
         agentId: route.agentId,
     });
@@ -350,17 +376,14 @@ export async function prepareSlackMessage(params) {
         });
     }
     const slackTo = isDirectMessage ? `user:${message.user}` : `channel:${message.channel}`;
-    const channelDescription = [channelInfo?.topic, channelInfo?.purpose]
-        .map((entry) => entry?.trim())
-        .filter((entry) => Boolean(entry))
-        .filter((entry, index, list) => list.indexOf(entry) === index)
-        .join("\n");
-    const systemPromptParts = [
-        channelDescription ? `Channel description: ${channelDescription}` : null,
-        channelConfig?.systemPrompt?.trim() || null,
-    ].filter((entry) => Boolean(entry));
-    const groupSystemPrompt = systemPromptParts.length > 0 ? systemPromptParts.join("\n\n") : undefined;
+    const { untrustedChannelMetadata, groupSystemPrompt } = resolveSlackRoomContextHints({
+        isRoomish,
+        channelInfo,
+        channelConfig,
+    });
     let threadStarterBody;
+    let threadHistoryBody;
+    let threadSessionPreviousTimestamp;
     let threadLabel;
     let threadStarterMedia = null;
     if (isThreadReply && threadTs) {
@@ -370,38 +393,89 @@ export async function prepareSlackMessage(params) {
             client: ctx.app.client,
         });
         if (starter?.text) {
-            const starterUser = starter.userId ? await ctx.resolveUserName(starter.userId) : null;
-            const starterName = starterUser?.name ?? starter.userId ?? "Unknown";
-            const starterWithId = `${starter.text}\n[slack message id: ${starter.ts ?? threadTs} channel: ${message.channel}]`;
-            threadStarterBody = formatThreadStarterEnvelope({
-                channel: "Slack",
-                author: starterName,
-                timestamp: starter.ts ? Math.round(Number(starter.ts) * 1000) : undefined,
-                body: starterWithId,
-                envelope: envelopeOptions,
-            });
+            // Keep thread starter as raw text; metadata is provided out-of-band in the system prompt.
+            threadStarterBody = starter.text;
             const snippet = starter.text.replace(/\s+/g, " ").slice(0, 80);
             threadLabel = `Slack thread ${roomLabel}${snippet ? `: ${snippet}` : ""}`;
             // If current message has no files but thread starter does, fetch starter's files
-            if (!media && starter.files && starter.files.length > 0) {
+            if (!effectiveDirectMedia && starter.files && starter.files.length > 0) {
                 threadStarterMedia = await resolveSlackMedia({
                     files: starter.files,
                     token: ctx.botToken,
                     maxBytes: ctx.mediaMaxBytes,
                 });
                 if (threadStarterMedia) {
-                    logVerbose(`slack: hydrated thread starter file ${threadStarterMedia.placeholder} from root message`);
+                    const starterPlaceholders = threadStarterMedia.map((m) => m.placeholder).join(", ");
+                    logVerbose(`slack: hydrated thread starter file ${starterPlaceholders} from root message`);
                 }
             }
         }
         else {
             threadLabel = `Slack thread ${roomLabel}`;
         }
+        // Fetch full thread history for new thread sessions
+        // This provides context of previous messages (including bot replies) in the thread
+        // Use the thread session key (not base session key) to determine if this is a new session
+        const threadInitialHistoryLimit = account.config?.thread?.initialHistoryLimit ?? 20;
+        threadSessionPreviousTimestamp = readSessionUpdatedAt({
+            storePath,
+            sessionKey, // Thread-specific session key
+        });
+        if (threadInitialHistoryLimit > 0 && !threadSessionPreviousTimestamp) {
+            const threadHistory = await resolveSlackThreadHistory({
+                channelId: message.channel,
+                threadTs,
+                client: ctx.app.client,
+                currentMessageTs: message.ts,
+                limit: threadInitialHistoryLimit,
+            });
+            if (threadHistory.length > 0) {
+                // Batch resolve user names to avoid N sequential API calls
+                const uniqueUserIds = [
+                    ...new Set(threadHistory.map((m) => m.userId).filter((id) => Boolean(id))),
+                ];
+                const userMap = new Map();
+                await Promise.all(uniqueUserIds.map(async (id) => {
+                    const user = await ctx.resolveUserName(id);
+                    if (user) {
+                        userMap.set(id, user);
+                    }
+                }));
+                const historyParts = [];
+                for (const historyMsg of threadHistory) {
+                    const msgUser = historyMsg.userId ? userMap.get(historyMsg.userId) : null;
+                    const msgSenderName = msgUser?.name ?? (historyMsg.botId ? `Bot (${historyMsg.botId})` : "Unknown");
+                    const isBot = Boolean(historyMsg.botId);
+                    const role = isBot ? "assistant" : "user";
+                    const msgWithId = `${historyMsg.text}\n[slack message id: ${historyMsg.ts ?? "unknown"} channel: ${message.channel}]`;
+                    historyParts.push(formatInboundEnvelope({
+                        channel: "Slack",
+                        from: `${msgSenderName} (${role})`,
+                        timestamp: historyMsg.ts ? Math.round(Number(historyMsg.ts) * 1000) : undefined,
+                        body: msgWithId,
+                        chatType: "channel",
+                        envelope: envelopeOptions,
+                    }));
+                }
+                threadHistoryBody = historyParts.join("\n\n");
+                logVerbose(`slack: populated thread history with ${threadHistory.length} messages for new session`);
+            }
+        }
     }
-    // Use thread starter media if current message has none
-    const effectiveMedia = media ?? threadStarterMedia;
+    // Use direct media (including forwarded attachment media) if available, else thread starter media
+    const effectiveMedia = effectiveDirectMedia ?? threadStarterMedia;
+    const firstMedia = effectiveMedia?.[0];
+    const inboundHistory = isRoomish && ctx.historyLimit > 0
+        ? (ctx.channelHistories.get(historyKey) ?? []).map((entry) => ({
+            sender: entry.sender,
+            body: entry.body,
+            timestamp: entry.timestamp,
+        }))
+        : undefined;
     const ctxPayload = finalizeInboundContext({
         Body: combinedBody,
+        BodyForAgent: rawBody,
+        InboundHistory: inboundHistory,
         RawBody: rawBody,
         CommandBody: rawBody,
         From: slackFrom,
@@ -412,6 +486,7 @@ export async function prepareSlackMessage(params) {
         ConversationLabel: envelopeFrom,
         GroupSubject: isRoomish ? roomLabel : undefined,
         GroupSystemPrompt: isRoomish ? groupSystemPrompt : undefined,
+        UntrustedContext: untrustedChannelMetadata ? [untrustedChannelMetadata] : undefined,
         SenderName: senderName,
         SenderId: senderId,
         Provider: "slack",
@@ -422,12 +497,19 @@ export async function prepareSlackMessage(params) {
         MessageThreadId: threadContext.messageThreadId,
         ParentSessionKey: threadKeys.parentSessionKey,
         ThreadStarterBody: threadStarterBody,
+        ThreadHistoryBody: threadHistoryBody,
+        IsFirstThreadTurn: isThreadReply && threadTs && !threadSessionPreviousTimestamp ? true : undefined,
         ThreadLabel: threadLabel,
         Timestamp: message.ts ? Math.round(Number(message.ts) * 1000) : undefined,
         WasMentioned: isRoomish ? effectiveWasMentioned : undefined,
-        MediaPath: effectiveMedia?.path,
-        MediaType: effectiveMedia?.contentType,
-        MediaUrl: effectiveMedia?.path,
+        MediaPath: firstMedia?.path,
+        MediaType: firstMedia?.contentType,
+        MediaUrl: firstMedia?.path,
+        MediaPaths: effectiveMedia && effectiveMedia.length > 0 ? effectiveMedia.map((m) => m.path) : undefined,
+        MediaUrls: effectiveMedia && effectiveMedia.length > 0 ? effectiveMedia.map((m) => m.path) : undefined,
+        MediaTypes: effectiveMedia && effectiveMedia.length > 0
+            ? effectiveMedia.map((m) => m.contentType ?? "")
+            : undefined,
         CommandAuthorized: commandAuthorized,
         OriginatingChannel: "slack",
         OriginatingTo: slackTo,
@@ -453,8 +535,9 @@ export async function prepareSlackMessage(params) {
         },
     });
     const replyTarget = ctxPayload.To ?? undefined;
-    if (!replyTarget)
+    if (!replyTarget) {
         return null;
+    }
     if (shouldLogVerbose()) {
         logVerbose(`slack inbound: channel=${message.channel} from=${slackFrom} preview="${preview}"`);
     }