@desplega.ai/agent-swarm 1.149.1 → 1.151.0

package/src/slack/assistant.ts

@@ -7,7 +7,6 @@ import { resolveSlackUserId, rewriteSlackMentions } from "./enrich";
 import { wasEventSeen } from "./event-dedup";
 import type { SlackFile } from "./files";
 import {
-  bufferedFileFailures,
   buildEffectiveText,
   createSlackTaskWithFiles,
   fetchSlackFiles,
@@ -128,21 +127,12 @@ export function createAssistant(): Assistant {
         // 1. Check if an agent is already working in this thread
         const workingAgent = await getAgentWorkingOnThread(channelId, threadTs);
 
-        // Follow-up message → route to the same agent. Buffered follow-ups
-        // carry the `[File: …]` lines only; their files are not attached.
+        // Follow-up message → buffer text and file metadata until the flush.
         if (workingAgent && workingAgent.status !== "offline" && isAdditiveSlack()) {
-          const unattached = bufferedFileFailures(files);
-          bufferThreadMessage(
-            channelId,
-            threadTs,
-            buildEffectiveText(messageText, files, unattached),
-            userId,
-            message.ts,
-          );
+          bufferThreadMessage(channelId, threadTs, messageText, userId, message.ts, files);
           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;
         }
@@ -167,6 +157,7 @@ export function createAssistant(): Assistant {
             {
               agentId: workingAgent.id,
               routingReason: "continuity",
+              routingSource: "engine_default",
               source: "slack",
               slackChannelId: channelId,
               slackThreadTs: threadTs,
@@ -249,6 +240,7 @@ export function createAssistant(): Assistant {
           {
             agentId: lead.id,
             routingReason: "skill",
+            routingSource: "engine_default",
             source: "slack",
             slackChannelId: channelId,
             slackThreadTs: threadTs,

package/src/slack/blocks.ts

@@ -555,7 +555,7 @@ export function buildTreeBlocks(roots: TreeNode[]): SlackBlock[] {
   );
 
   const treeTexts = roots.map(renderTree);
-  const blocks: SlackBlock[] = [sectionBlock(treeTexts.join("\n\n"))];
+  const blocks: SlackBlock[] = treeTexts.length > 0 ? [sectionBlock(treeTexts.join("\n\n"))] : [];
 
   // Attachment blocks for completed nodes, with per-tree-message cap.
   const attachmentNodes = collectAttachmentNodes(roots);

package/src/slack/handlers.ts

@@ -1,14 +1,19 @@
 import type { App } from "@slack/bolt";
 import type { WebClient } from "@slack/web-api";
+import { z } from "zod";
 import {
   getAgentById,
   getAgentWorkingOnThread,
+  getAllAgents,
   getLeadAgent,
   getMostRecentTaskInThread,
   getTasksByAgentId,
 } from "../be/db";
+import { dispatchPre } from "../extensions/dispatcher";
 import { resolveTemplate } from "../prompts/resolver";
 import { slackContextKey } from "../tasks/context-key";
+import { TaskCreationBlockedError } from "../tasks/errors";
+import { scrubSecrets } from "../utils/secret-scrubber";
 import { workflowEventBus } from "../workflows/event-bus";
 import { ackSlackMessage, reactionName } from "./ack";
 import { buildTreeBlocks, type TreeNode } from "./blocks";
@@ -16,14 +21,19 @@ import { enrichSlackUserEmail, resolveSlackUserId, rewriteSlackMentions } from "
 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";
+import {
+  broadcastMatches,
+  extractTaskFromMessage,
+  hasOtherUserMention,
+  routeMessage,
+} from "./router";
+import type { AgentMatch } from "./types";
 // Side-effect import: registers all Slack event templates in the in-memory registry
 import "./templates";
 import { isEnvFlagEnabled } from "../utils/env-flag";
@@ -33,6 +43,17 @@ import { formatSlackSteeringAck, requestSlackThreadSteering } from "./steering";
 import { bufferThreadMessage, getBufferMessageCount, instantFlush } from "./thread-buffer";
 import { registerTreeMessage } from "./watcher";
 
+/** Runtime check for `pre.slack.route` modifications (mirrors `SlackRouteModify`). */
+const SlackRouteModifySchema = z
+  .object({
+    target: z.discriminatedUnion("kind", [
+      z.object({ kind: z.literal("agent"), agentId: z.string().min(1) }).strict(),
+      z.object({ kind: z.literal("lead") }).strict(),
+      z.object({ kind: z.literal("broadcast") }).strict(),
+    ]),
+  })
+  .strict();
+
 // User filtering configuration from environment variables
 const allowedEmailDomains = (process.env.SLACK_ALLOWED_EMAIL_DOMAINS || "")
   .split(",")
@@ -103,7 +124,7 @@ export function checkUserAccess(
  * Check if a user is allowed to interact with the swarm.
  * Returns true if filtering is disabled, user is in whitelist, or user's email domain is allowed.
  */
-async function isUserAllowed(client: WebClient, userId: string): Promise<boolean> {
+export async function isUserAllowed(client: WebClient, userId: string): Promise<boolean> {
   // If no filtering configured, allow all users (backwards compatible)
   if (!filteringEnabled) {
     return true;
@@ -445,11 +466,13 @@ export function registerMessageHandler(app: App): void {
       sampleContext: msg.text ?? "",
     });
 
-    // Emit workflow trigger event for Slack messages
+    // Keep channel/user for legacy consumers and channelId/userId for the extension contract.
     workflowEventBus.emit("slack.message", {
       channel: msg.channel,
+      channelId: msg.channel,
       text: msg.text,
       user: msg.user,
+      userId: msg.user,
       ts: msg.ts,
       threadTs: msg.thread_ts,
     });
@@ -487,11 +510,7 @@ export function registerMessageHandler(app: App): void {
       false,
     );
     if (additiveSlack && msg.thread_ts) {
-      // 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();
+      const stripped = (msg.text ?? "").replace(/<@[A-Z0-9]+>/g, "").trim();
       if (
         stripped.startsWith("!now") &&
         (await hasSwarmThreadActivity(client, msg.channel, msg.thread_ts))
@@ -503,15 +522,14 @@ export function registerMessageHandler(app: App): void {
           `[Slack] !now command detected in thread ${threadKey}${nowMessage ? ` with message: "${nowMessage}"` : ""}`,
         );
 
-        if (nowMessage) {
-          bufferThreadMessage(msg.channel, msg.thread_ts, nowMessage, msg.user, msg.ts);
+        if (nowMessage || msg.files?.length) {
+          bufferThreadMessage(msg.channel, msg.thread_ts, nowMessage, msg.user, msg.ts, msg.files);
         }
 
         // Instant flush — no dependency
         await instantFlush(threadKey);
 
         await ackSlackMessage(client, msg.channel, msg.ts, reactionName("now"), "now");
-        await notifySlackFileFailures(client, msg.channel, msg.thread_ts, unattached);
 
         return;
       }
@@ -538,14 +556,13 @@ export function registerMessageHandler(app: App): void {
 
       if (hasSwarmActivity) {
         const threadKey = `${msg.channel}:${msg.thread_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.text ?? "",
           msg.user,
           msg.ts,
+          msg.files,
         );
 
         // Slack feedback: react with the accepted reaction on first buffer, buffered on appends
@@ -554,7 +571,6 @@ 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
       }
@@ -565,7 +581,61 @@ export function registerMessageHandler(app: App): void {
     const routingThreadContext = msg.thread_ts
       ? { channelId: msg.channel, threadTs: msg.thread_ts }
       : undefined;
-    const matches = await routeMessage(
+    const routeResult = await dispatchPre(
+      "pre.slack.route",
+      {
+        channelId: msg.channel,
+        userId: msg.user,
+        text: routingText,
+        ...(msg.thread_ts ? { threadTs: msg.thread_ts } : {}),
+        botMentioned: botMentioned || isImplicitMention,
+        ...(routingThreadContext ? { threadContext: routingThreadContext } : {}),
+      },
+      {
+        // A runtime-invalid target (missing, null, unknown kind) is an extension
+        // failure, not a routing input; the built-in router keeps handling the message.
+        validateModify: (data) => {
+          const parsed = SlackRouteModifySchema.safeParse(data);
+          return parsed.success
+            ? { success: true, data: parsed.data }
+            : { success: false, error: new Error(parsed.error.message) };
+        },
+      },
+    );
+    if (routeResult.action === "block") {
+      console.info("[Slack] Extension blocked message routing:", scrubSecrets(routeResult.reason));
+      return;
+    }
+
+    let matches: AgentMatch[] | undefined;
+    if (routeResult.action === "modify") {
+      const { target } = routeResult.data;
+      if (target.kind === "agent") {
+        const agent = await getAgentById(target.agentId);
+        if (agent) {
+          matches = [{ agent, matchedText: "extension" }];
+        } else {
+          console.warn(
+            "[Slack] Extension selected an unknown agent. Using the built-in router:",
+            scrubSecrets(target.agentId),
+          );
+        }
+      } else if (target.kind === "lead") {
+        const leadAgent = await getLeadAgent();
+        if (leadAgent) {
+          matches = [{ agent: leadAgent, matchedText: "extension" }];
+        } else {
+          console.warn(
+            scrubSecrets(
+              "[Slack] Extension selected the lead, but no lead exists. Using the built-in router.",
+            ),
+          );
+        }
+      } else {
+        matches = broadcastMatches(await getAllAgents());
+      }
+    }
+    matches ??= await routeMessage(
       routingText,
       botUserId,
       botMentioned || isImplicitMention,
@@ -625,6 +695,7 @@ export function registerMessageHandler(app: App): void {
         {
           agentId: lead?.id,
           routingReason: lead ? "skill" : undefined,
+          routingSource: lead ? "engine_default" : undefined,
           source: "slack",
           slackChannelId: msg.channel,
           slackThreadTs: threadTs,
@@ -741,6 +812,7 @@ export function registerMessageHandler(app: App): void {
             {
               agentId: agent.id,
               routingReason: "human_pinned",
+              routingSource: "engine_default",
               source: "slack",
               slackChannelId: msg.channel,
               slackThreadTs: threadTs,
@@ -765,6 +837,7 @@ export function registerMessageHandler(app: App): void {
           {
             agentId: agent.id,
             routingReason: "human_pinned",
+            routingSource: "engine_default",
             source: "slack",
             slackChannelId: msg.channel,
             slackThreadTs: threadTs,
@@ -790,8 +863,11 @@ export function registerMessageHandler(app: App): void {
         } else {
           results.assigned.push({ agentName: agent.name, taskId: task.id });
         }
-      } catch {
-        results.failed.push({ agentName: agent.name, reason: "error" });
+      } catch (error) {
+        results.failed.push({
+          agentName: agent.name,
+          reason: error instanceof TaskCreationBlockedError ? error.reason : "error",
+        });
       }
     }
 
@@ -807,6 +883,18 @@ export function registerMessageHandler(app: App): void {
       );
       if (isSlackRenderV2Enabled()) {
         if (successfulTaskIds.length > 0) await ensureSlackThreadTree(successfulTaskIds);
+        // The tree only renders tasks that exist. A blocked or failed assignment must
+        // still be answered, or the user gets silence for a policy block.
+        if (results.failed.length > 0) {
+          const failedLines = results.failed
+            .map((f) => `⚠️ Could not assign to: *${f.agentName}* — ${f.reason}`)
+            .join("\n");
+          await say({
+            text: `Could not assign to: ${results.failed.map((f) => f.agentName).join(", ")}`,
+            blocks: [{ type: "context", elements: [{ type: "mrkdwn", text: failedLines }] }],
+            thread_ts: msg.thread_ts || msg.ts,
+          });
+        }
       } else {
         // Build initial tree nodes from assignment results
         const initialNodes: TreeNode[] = results.assigned.map(({ agentName, taskId }) => ({

package/src/slack/inbound-files.ts

@@ -134,9 +134,9 @@ export function buildEffectiveText(
 }
 
 /**
- * The files of a follow-up that `ADDITIVE_SLACK` queues instead of turning into
- * a task right away: the queued text keeps their `[File: …]` lines, but they
- * are not attached, so they're reported like any other unattached file.
+ * Fallback when a buffered follow-up cannot fetch its files (for example,
+ * the Slack app is unavailable at flush). Keep their names in the task and
+ * mark them unattached. Normal flushes report specific download/storage failures.
  */
 export function bufferedFileFailures(files: SlackFile[] | undefined): SlackFileFailure[] {
   return (files ?? []).map((file) => ({ file, reason: BUFFERED_REASON }));
@@ -288,11 +288,15 @@ export async function createSlackTaskWithFiles(
   inbound: InboundSlackFiles,
 ): Promise<{ task: AgentTask; unattached: SlackFileFailure[] }> {
   if (inbound.fetched.length === 0) {
-    const task = await createTaskWithSiblingAwareness(description, options);
+    const task = await createTaskWithSiblingAwareness(description, options, { origin: "slack" });
     return { task, unattached: inbound.failed };
   }
 
-  const task = await createTaskWithSiblingAwareness(description, { ...options, status: "draft" });
+  const task = await createTaskWithSiblingAwareness(
+    description,
+    { ...options, status: "draft" },
+    { origin: "slack" },
+  );
   const unattached = [...inbound.failed];
   // Uploads run one after another and can outlast the abandoned-draft sweep's
   // window; renewing the lease keeps the sweep from promoting a live batch.