@desplega.ai/agent-swarm 1.145.0 → 1.147.0

package/src/slack/assistant.ts

@@ -2,10 +2,17 @@ import { Assistant } from "@slack/bolt";
 import { getAgentWorkingOnThread, getLeadAgent, getMostRecentTaskInThread } from "../be/db";
 import { resolveTemplate } from "../prompts/resolver";
 import { slackContextKey } from "../tasks/context-key";
-import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { ackSlackMessage, reactionName } from "./ack";
 import { resolveSlackUserId, rewriteSlackMentions } from "./enrich";
 import { wasEventSeen } from "./event-dedup";
+import type { SlackFile } from "./files";
+import {
+  bufferedFileFailures,
+  buildEffectiveText,
+  createSlackTaskWithFiles,
+  fetchSlackFiles,
+  notifySlackFileFailures,
+} from "./inbound-files";
 import { ensureSlackThreadTree, isSlackRenderV2Enabled } from "./render-v2";
 import { hasOtherUserMention } from "./router";
 import { bufferThreadMessage, getBufferMessageCount } from "./thread-buffer";
@@ -80,12 +87,10 @@ export function createAssistant(): Assistant {
         const threadTs = (msg.thread_ts as string) || message.ts;
         const channelId = message.channel;
         const messageText = (msg.text as string) || "";
+        // `file_share` messages land here too: an image sent with no caption
+        // arrives with empty `text` and everything in `files`.
+        const files = msg.files as SlackFile[] | undefined;
         const userId = (msg.user as string) || "";
-        // Any in-body `<@U…>` mention the requester typed is rewritten via
-        // the identity primitive before it reaches agent-visible task text —
-        // never a raw Slack ID. Bot-mention routing checks below use the
-        // raw `messageText`, not this rendered copy.
-        const renderedMessageText = await rewriteSlackMentions(messageText);
 
         // Resolve the bot's own Slack user ID (cached after first call) so we can
         // check whether this message is actually addressed to us.
@@ -123,30 +128,55 @@ export function createAssistant(): Assistant {
         // 1. Check if an agent is already working in this thread
         const workingAgent = await getAgentWorkingOnThread(channelId, threadTs);
 
-        if (workingAgent && workingAgent.status !== "offline") {
-          // Follow-up message → route to the same agent
-          if (isAdditiveSlack()) {
-            bufferThreadMessage(channelId, threadTs, messageText, userId, message.ts);
-            const count = getBufferMessageCount(`${channelId}:${threadTs}`);
-            const event = count === 1 ? "accepted" : "buffered";
-            await ackSlackMessage(client, channelId, message.ts, reactionName(event), event);
-            await safeSetStatus("Queuing follow-up...");
-            return;
-          }
+        // Follow-up message → route to the same agent. Buffered follow-ups
+        // carry the `[File: …]` lines only; their files are not attached.
+        if (workingAgent && workingAgent.status !== "offline" && isAdditiveSlack()) {
+          const unattached = bufferedFileFailures(files);
+          bufferThreadMessage(
+            channelId,
+            threadTs,
+            buildEffectiveText(messageText, files, unattached),
+            userId,
+            message.ts,
+          );
+          const count = getBufferMessageCount(`${channelId}:${threadTs}`);
+          const event = count === 1 ? "accepted" : "buffered";
+          await ackSlackMessage(client, channelId, message.ts, reactionName(event), event);
+          await notifySlackFileFailures(client, channelId, threadTs, unattached);
+          await safeSetStatus("Queuing follow-up...");
+          return;
+        }
+
+        // Fetch shared files before the task text is final: a file that can't be
+        // downloaded is flagged in it.
+        if (files?.length) await safeSetStatus("Downloading attachments...");
+        await using inbound = await fetchSlackFiles(client, files);
+        // Any in-body `<@U…>` mention the requester typed is rewritten via
+        // the identity primitive before it reaches agent-visible task text —
+        // never a raw Slack ID. Bot-mention routing checks above use the
+        // raw `messageText`, not this rendered copy.
+        const renderedMessageText = await rewriteSlackMentions(
+          buildEffectiveText(messageText, inbound.files, inbound.failed),
+        );
 
+        if (workingAgent && workingAgent.status !== "offline") {
           // Otherwise, create a follow-up task for the working agent
           const latestTask = await getMostRecentTaskInThread(channelId, threadTs);
-          const task = await createTaskWithSiblingAwareness(renderedMessageText, {
-            agentId: workingAgent.id,
-            source: "slack",
-            slackChannelId: channelId,
-            slackThreadTs: threadTs,
-            slackTriggerMessageTs: message.ts,
-            slackUserId: userId,
-            parentTaskId: latestTask?.id,
-            requestedByUserId,
-            contextKey: slackContextKey({ channelId, threadTs }),
-          });
+          const { task, unattached } = await createSlackTaskWithFiles(
+            renderedMessageText,
+            {
+              agentId: workingAgent.id,
+              source: "slack",
+              slackChannelId: channelId,
+              slackThreadTs: threadTs,
+              slackTriggerMessageTs: message.ts,
+              slackUserId: userId,
+              parentTaskId: latestTask?.id,
+              requestedByUserId,
+              contextKey: slackContextKey({ channelId, threadTs }),
+            },
+            inbound,
+          );
           await ackSlackMessage(
             client,
             channelId,
@@ -154,6 +184,7 @@ export function createAssistant(): Assistant {
             reactionName("accepted"),
             "accepted",
           );
+          await notifySlackFileFailures(client, channelId, threadTs, unattached);
 
           if (isSlackRenderV2Enabled()) await ensureSlackThreadTree([task.id]);
 
@@ -182,15 +213,19 @@ export function createAssistant(): Assistant {
         const lead = await getLeadAgent();
         if (!lead) {
           // No lead — still queue the task
-          const task = await createTaskWithSiblingAwareness(renderedMessageText + channelContext, {
-            source: "slack",
-            slackChannelId: channelId,
-            slackThreadTs: threadTs,
-            slackTriggerMessageTs: message.ts,
-            slackUserId: userId,
-            requestedByUserId,
-            contextKey: slackContextKey({ channelId, threadTs }),
-          });
+          const { task, unattached } = await createSlackTaskWithFiles(
+            renderedMessageText + channelContext,
+            {
+              source: "slack",
+              slackChannelId: channelId,
+              slackThreadTs: threadTs,
+              slackTriggerMessageTs: message.ts,
+              slackUserId: userId,
+              requestedByUserId,
+              contextKey: slackContextKey({ channelId, threadTs }),
+            },
+            inbound,
+          );
           await ackSlackMessage(
             client,
             channelId,
@@ -198,6 +233,7 @@ export function createAssistant(): Assistant {
             reactionName("accepted"),
             "accepted",
           );
+          await notifySlackFileFailures(client, channelId, threadTs, unattached);
           if (isSlackRenderV2Enabled()) {
             await ensureSlackThreadTree([task.id]);
           } else {
@@ -207,17 +243,22 @@ export function createAssistant(): Assistant {
           return;
         }
 
-        const task = await createTaskWithSiblingAwareness(renderedMessageText + channelContext, {
-          agentId: lead.id,
-          source: "slack",
-          slackChannelId: channelId,
-          slackThreadTs: threadTs,
-          slackTriggerMessageTs: message.ts,
-          slackUserId: userId,
-          requestedByUserId,
-          contextKey: slackContextKey({ channelId, threadTs }),
-        });
+        const { task, unattached } = await createSlackTaskWithFiles(
+          renderedMessageText + channelContext,
+          {
+            agentId: lead.id,
+            source: "slack",
+            slackChannelId: channelId,
+            slackThreadTs: threadTs,
+            slackTriggerMessageTs: message.ts,
+            slackUserId: userId,
+            requestedByUserId,
+            contextKey: slackContextKey({ channelId, threadTs }),
+          },
+          inbound,
+        );
         await ackSlackMessage(client, channelId, message.ts, reactionName("accepted"), "accepted");
+        await notifySlackFileFailures(client, channelId, threadTs, unattached);
         if (isSlackRenderV2Enabled()) await ensureSlackThreadTree([task.id]);
         // setStatus shows typing indicator — watcher will post final result when done
       } catch (error) {

package/src/slack/handlers.test.ts

@@ -17,15 +17,13 @@ import { createAssistant } from "./assistant";
 import * as slackEnrichModule from "./enrich";
 import type { SlackFile } from "./files";
 import {
-  buildAttachmentText,
-  buildEffectiveText,
   checkUserAccess,
-  formatFileSize,
   isBotMessage,
   isSwarmThreadRoot,
   registerMessageHandler,
   type UserFilterConfig,
 } from "./handlers";
+import { buildAttachmentText, buildEffectiveText, formatFileSize } from "./inbound-files";
 import { SLACK_REACTION_CONFIG_KEYS } from "./reaction-shortcode";
 
 describe("checkUserAccess", () => {

package/src/slack/handlers.ts

@@ -9,13 +9,20 @@ import {
 } from "../be/db";
 import { resolveTemplate } from "../prompts/resolver";
 import { slackContextKey } from "../tasks/context-key";
-import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { workflowEventBus } from "../workflows/event-bus";
 import { ackSlackMessage, reactionName } from "./ack";
 import { buildTreeBlocks, type TreeNode } from "./blocks";
 import { enrichSlackUserEmail, resolveSlackUserId, rewriteSlackMentions } from "./enrich";
 import { wasEventSeen } from "./event-dedup";
 import type { SlackFile } from "./files";
+import {
+  bufferedFileFailures,
+  buildEffectiveText,
+  createSlackTaskWithFiles,
+  fetchSlackFiles,
+  notifySlackFileFailures,
+  type SlackFileFailure,
+} from "./inbound-files";
 import { extractTaskFromMessage, hasOtherUserMention, routeMessage } from "./router";
 // Side-effect import: registers all Slack event templates in the in-memory registry
 import "./templates";
@@ -336,45 +343,6 @@ async function getThreadContext(
   }
 }
 
-/**
- * Format a file size in bytes to a human-readable string.
- */
-export function formatFileSize(bytes: number): string {
-  if (bytes < 1024) return `${bytes} B`;
-  if (bytes < 1024 * 1024) return `${(bytes / 1024).toFixed(1)} KB`;
-  if (bytes < 1024 * 1024 * 1024) return `${(bytes / (1024 * 1024)).toFixed(1)} MB`;
-  return `${(bytes / (1024 * 1024 * 1024)).toFixed(1)} GB`;
-}
-
-/**
- * Build a text representation of file attachments for inclusion in messages.
- * Each file is formatted as: [File: filename.ext (mimetype, size) id=FILE_ID]
- */
-export function buildAttachmentText(files: SlackFile[]): string {
-  return files
-    .map((f) => `[File: ${f.name} (${f.mimetype}, ${formatFileSize(f.size)}) id=${f.id}]`)
-    .join("\n");
-}
-
-/**
- * Build the effective message text from the original text and any file attachments.
- * - Text only: returns the text as-is
- * - Files only: returns the attachment metadata
- * - Both: returns text followed by attachment metadata
- */
-export function buildEffectiveText(text: string | undefined, files?: SlackFile[]): string {
-  const hasText = !!text?.trim();
-  const hasFiles = files && files.length > 0;
-
-  if (hasText && hasFiles) {
-    return `${text}\n\n${buildAttachmentText(files)}`;
-  }
-  if (hasFiles) {
-    return buildAttachmentText(files);
-  }
-  return text || "";
-}
-
 // Message deduplication (prevents duplicate event processing)
 const processedMessages = new Set<string>();
 const MESSAGE_DEDUP_TTL = 60_000; // 1 minute
@@ -501,9 +469,11 @@ export function registerMessageHandler(app: App): void {
     // Check if bot was mentioned (in original text only)
     const botMentioned = !!msg.text?.includes(`<@${botUserId}>`);
 
-    // Detect assistant thread context — file_share messages in DM assistant threads
-    // bypass the assistant handler and land here instead. Treat them as implicit mentions
-    // so they route to the lead agent rather than being silently dropped.
+    // Detect assistant thread context. Bolt's Assistant middleware claims DM thread
+    // messages with no subtype or `file_share` (`isAssistantMessage` in @slack/bolt), so
+    // those — file uploads included — are handled in assistant.ts. An assistant-thread
+    // message that still lands here is treated as an implicit mention so it routes to
+    // the lead agent rather than being silently dropped.
     // Guard: suppress implicit mention when the message @-mentions someone else but NOT us —
     // those messages are addressed to a different agent/user (e.g. Devin) and must not spawn.
     const isAssistantThread = !!msg.assistant_thread;
@@ -517,7 +487,11 @@ export function registerMessageHandler(app: App): void {
       false,
     );
     if (additiveSlack && msg.thread_ts) {
-      const stripped = effectiveText.replace(/<@[A-Z0-9]+>/g, "").trim();
+      // A !now follow-up is buffered too: its files ride along as marked `[File: …]` lines only.
+      const unattached = bufferedFileFailures(msg.files);
+      const stripped = buildEffectiveText(msg.text, msg.files, unattached)
+        .replace(/<@[A-Z0-9]+>/g, "")
+        .trim();
       if (
         stripped.startsWith("!now") &&
         (await hasSwarmThreadActivity(client, msg.channel, msg.thread_ts))
@@ -537,6 +511,7 @@ export function registerMessageHandler(app: App): void {
         await instantFlush(threadKey);
 
         await ackSlackMessage(client, msg.channel, msg.ts, reactionName("now"), "now");
+        await notifySlackFileFailures(client, msg.channel, msg.thread_ts, unattached);
 
         return;
       }
@@ -563,7 +538,15 @@ export function registerMessageHandler(app: App): void {
 
       if (hasSwarmActivity) {
         const threadKey = `${msg.channel}:${msg.thread_ts}`;
-        bufferThreadMessage(msg.channel, msg.thread_ts, effectiveText, msg.user, msg.ts);
+        // Buffered follow-ups carry the `[File: …]` lines only; their files are not attached.
+        const unattached = bufferedFileFailures(msg.files);
+        bufferThreadMessage(
+          msg.channel,
+          msg.thread_ts,
+          buildEffectiveText(msg.text, msg.files, unattached),
+          msg.user,
+          msg.ts,
+        );
 
         // Slack feedback: react with the accepted reaction on first buffer, buffered on appends
         const count = getBufferMessageCount(threadKey);
@@ -571,6 +554,7 @@ export function registerMessageHandler(app: App): void {
         const name = reactionName(event);
         console.log(`[Slack] Additive buffer: ${threadKey} (message #${count}, reaction: ${name})`);
         await ackSlackMessage(client, msg.channel, msg.ts, name, event);
+        await notifySlackFileFailures(client, msg.channel, msg.thread_ts, unattached);
 
         return; // Don't process further — buffer will flush
       }
@@ -602,9 +586,11 @@ export function registerMessageHandler(app: App): void {
         return;
       }
 
+      await using inbound = await fetchSlackFiles(client, msg.files);
+      const taskText = buildEffectiveText(msg.text, inbound.files, inbound.failed);
       const taskDescription = isImplicitMention
-        ? effectiveText
-        : extractTaskFromMessage(effectiveText, botUserId);
+        ? taskText
+        : extractTaskFromMessage(taskText, botUserId);
       if (!taskDescription) {
         if (!isImplicitMention && !isSlackRenderV2Enabled()) {
           await say({
@@ -634,17 +620,22 @@ export function registerMessageHandler(app: App): void {
       }
 
       const lead = await getLeadAgent();
-      const task = await createTaskWithSiblingAwareness(fullTaskDescription, {
-        agentId: lead?.id,
-        source: "slack",
-        slackChannelId: msg.channel,
-        slackThreadTs: threadTs,
-        slackTriggerMessageTs: msg.ts,
-        slackUserId: msg.user,
-        requestedByUserId,
-        contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
-      });
+      const { task, unattached } = await createSlackTaskWithFiles(
+        fullTaskDescription,
+        {
+          agentId: lead?.id,
+          source: "slack",
+          slackChannelId: msg.channel,
+          slackThreadTs: threadTs,
+          slackTriggerMessageTs: msg.ts,
+          slackUserId: msg.user,
+          requestedByUserId,
+          contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
+        },
+        inbound,
+      );
       await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
+      await notifySlackFileFailures(client, msg.channel, threadTs, unattached);
 
       if (isSlackRenderV2Enabled()) {
         await ensureSlackThreadTree([task.id]);
@@ -668,8 +659,12 @@ export function registerMessageHandler(app: App): void {
       return;
     }
 
-    // Extract task description (using effective text which includes attachment metadata)
-    const taskDescription = extractTaskFromMessage(effectiveText, botUserId);
+    // Extract task description (the text plus a `[File: …]` line per attachment)
+    await using inbound = await fetchSlackFiles(client, msg.files);
+    const taskDescription = extractTaskFromMessage(
+      buildEffectiveText(msg.text, inbound.files, inbound.failed),
+      botUserId,
+    );
     if (!taskDescription) {
       if (!isSlackRenderV2Enabled()) {
         await say({
@@ -706,6 +701,7 @@ export function registerMessageHandler(app: App): void {
       steered: Array<{ agentName: string; acknowledgement: string }>;
       failed: Array<{ agentName: string; reason: string }>;
     } = { assigned: [], queued: [], steered: [], failed: [] };
+    const unattached: SlackFileFailure[] = [];
 
     for (const match of matches) {
       const agent = await getAgentById(match.agent.id);
@@ -718,15 +714,18 @@ export function registerMessageHandler(app: App): void {
       try {
         const latestTask = await getMostRecentTaskInThread(msg.channel, threadTs);
         if (agent.isLead) {
-          const steering = msg.thread_ts
-            ? await requestSlackThreadSteering({
-                channelId: msg.channel,
-                threadTs,
-                message: taskDescription,
-                messageTimestamps: [msg.ts],
-                requestedByUserId,
-              })
-            : null;
+          // Steering only carries text into the running session; a message with
+          // files becomes a follow-up task so the files land as attachments.
+          const steering =
+            msg.thread_ts && inbound.files.length === 0
+              ? await requestSlackThreadSteering({
+                  channelId: msg.channel,
+                  threadTs,
+                  message: taskDescription,
+                  messageTimestamps: [msg.ts],
+                  requestedByUserId,
+                })
+              : null;
           if (steering) {
             await ackSlackMessage(client, msg.channel, msg.ts, reactionName("steered"), "steered");
             results.steered.push({
@@ -736,33 +735,45 @@ export function registerMessageHandler(app: App): void {
             continue;
           }
 
-          const task = await createTaskWithSiblingAwareness(fullTaskDescription, {
+          const created = await createSlackTaskWithFiles(
+            fullTaskDescription,
+            {
+              agentId: agent.id,
+              source: "slack",
+              slackChannelId: msg.channel,
+              slackThreadTs: threadTs,
+              slackTriggerMessageTs: msg.ts,
+              slackUserId: msg.user,
+              parentTaskId: latestTask?.id,
+              requestedByUserId,
+              contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
+            },
+            inbound,
+          );
+          const { task } = created;
+          unattached.push(...created.unattached);
+          await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
+          results.assigned.push({ agentName: agent.name, taskId: task.id });
+          continue;
+        }
+
+        // Workers receive tasks as before
+        const created = await createSlackTaskWithFiles(
+          fullTaskDescription,
+          {
             agentId: agent.id,
             source: "slack",
             slackChannelId: msg.channel,
             slackThreadTs: threadTs,
             slackTriggerMessageTs: msg.ts,
             slackUserId: msg.user,
-            parentTaskId: latestTask?.id,
             requestedByUserId,
             contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
-          });
-          await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
-          results.assigned.push({ agentName: agent.name, taskId: task.id });
-          continue;
-        }
-
-        // Workers receive tasks as before
-        const task = await createTaskWithSiblingAwareness(fullTaskDescription, {
-          agentId: agent.id,
-          source: "slack",
-          slackChannelId: msg.channel,
-          slackThreadTs: threadTs,
-          slackTriggerMessageTs: msg.ts,
-          slackUserId: msg.user,
-          requestedByUserId,
-          contextKey: slackContextKey({ channelId: msg.channel, threadTs }),
-        });
+          },
+          inbound,
+        );
+        const { task } = created;
+        unattached.push(...created.unattached);
         await ackSlackMessage(client, msg.channel, msg.ts, reactionName("accepted"), "accepted");
 
         // Check if agent has an in-progress task in this thread (queued follow-up)
@@ -781,6 +792,10 @@ export function registerMessageHandler(app: App): void {
       }
     }
 
+    if (results.assigned.length + results.queued.length > 0) {
+      await notifySlackFileFailures(client, msg.channel, threadTs, unattached);
+    }
+
     // Send consolidated summary as initial tree with Block Kit
     const totalResults = results.assigned.length + results.queued.length + results.failed.length;
     if (totalResults > 0) {