@desplega.ai/agent-swarm 1.20.0 → 1.51.2

package/src/slack/router.ts

@@ -1,78 +1,18 @@
 import { getAgentById, getAgentWorkingOnThread, getAllAgents } from "../be/db";
 import type { AgentMatch } from "./types";
 
-interface ThreadContext {
+export interface ThreadContext {
   channelId: string;
   threadTs: string;
 }
 
-// Common 3-letter words to exclude from matching
-const COMMON_WORDS = new Set([
-  "the",
-  "and",
-  "for",
-  "are",
-  "but",
-  "not",
-  "you",
-  "all",
-  "can",
-  "had",
-  "her",
-  "was",
-  "one",
-  "our",
-  "out",
-  "has",
-  "his",
-  "how",
-  "its",
-  "let",
-  "may",
-  "new",
-  "now",
-  "old",
-  "see",
-  "way",
-  "who",
-  "boy",
-  "did",
-  "get",
-  "say",
-  "she",
-  "too",
-  "use",
-  "hey",
-  "hi",
-  "hello",
-  "please",
-  "help",
-]);
-
-/**
- * Check if a word is suitable for agent name matching.
- * Allows 3+ char words if they're not common words.
- * Always allows uppercase words (CEO, CTO, etc).
- */
-function isMatchableWord(word: string): boolean {
-  if (word.length < 3) return false;
-  // Always allow fully uppercase words (acronyms like CEO, CTO)
-  if (word === word.toUpperCase() && word.length >= 3) return true;
-  // Allow 3+ char words that aren't common
-  if (word.length >= 3 && !COMMON_WORDS.has(word.toLowerCase())) return true;
-  return false;
-}
-
 /**
  * Routes a Slack message to the appropriate agent(s) based on mentions.
  *
  * Routing rules:
  * - `swarm#<uuid>` → exact agent by ID
  * - `swarm#all` → all non-lead agents
- * - Partial name match (3+ chars, not common words) → agent by name
- * - Multiple partial matches → route to lead (let lead decide)
- * - Thread follow-up (no match but agent working on thread) → route to that agent
- * - Bot @mention only → lead agent
+ * - Everything else → lead agent
  */
 export function routeMessage(
   text: string,
@@ -104,46 +44,28 @@ export function routeMessage(
     }
   }
 
-  // Check for partial name matches (3+ chars, not common words)
-  if (matches.length === 0) {
-    for (const agent of agents) {
-      const nameWords = agent.name.split(/\s+/).filter(isMatchableWord);
-      for (const word of nameWords) {
-        const regex = new RegExp(`\\b${escapeRegex(word)}\\b`, "i");
-        if (regex.test(text)) {
-          if (!matches.some((m) => m.agent.id === agent.id)) {
-            matches.push({ agent, matchedText: word });
-          }
-          break;
-        }
-      }
-    }
-
-    // If multiple agents matched a partial name, route to lead instead (let lead decide)
-    if (matches.length > 1) {
-      const lead = agents.find((a) => a.isLead);
-      if (lead) {
-        const matchedWords = matches.map((m) => m.matchedText).join(", ");
-        const matchedAgents = matches.map((m) => m.agent.name).join(", ");
-        return [
-          {
-            agent: lead,
-            matchedText: `ambiguous match "${matchedWords}" (could be: ${matchedAgents})`,
-          },
-        ];
-      }
-    }
-  }
-
-  // Thread follow-up: If no matches and we're in a thread, check if an agent is working on it
+  // Thread follow-up — route to agent already working in this thread
   if (matches.length === 0 && threadContext) {
     const workingAgent = getAgentWorkingOnThread(threadContext.channelId, threadContext.threadTs);
     if (workingAgent && workingAgent.status !== "offline") {
+      console.log(
+        `[Slack] Thread follow-up: routing to agent ${workingAgent.name} (${workingAgent.id}) in thread ${threadContext.threadTs}`,
+      );
       matches.push({ agent: workingAgent, matchedText: "thread follow-up" });
+    } else if (workingAgent) {
+      // Agent is offline but thread has history — route to lead without requiring @mention
+      console.log(
+        `[Slack] Thread follow-up: agent ${workingAgent.name} is offline, routing to lead`,
+      );
+      const allAgents = getAllAgents();
+      const lead = allAgents.find((a) => a.isLead && a.status !== "offline");
+      if (lead) {
+        matches.push({ agent: lead, matchedText: "thread follow-up (lead fallback)" });
+      }
     }
   }
 
-  // If only bot was mentioned and no agents matched, route to lead
+  // Default to lead for everything else
   if (matches.length === 0 && botMentioned) {
     const lead = agents.find((a) => a.isLead);
     if (lead) {
@@ -154,10 +76,6 @@ export function routeMessage(
   return matches;
 }
 
-function escapeRegex(str: string): string {
-  return str.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
-}
-
 /**
  * Extracts the task description from a message, removing bot mentions and agent references.
  */

package/src/slack/templates.ts

@@ -0,0 +1,55 @@
+/**
+ * Slack event prompt template definitions.
+ *
+ * Each template is registered at module load time via registerTemplate().
+ * Handlers import this module for the side-effect of registration.
+ */
+
+import { registerTemplate } from "../prompts/registry";
+
+// ============================================================================
+// Assistant messages (Slack UI messages, not agent prompts)
+// ============================================================================
+
+registerTemplate({
+  eventType: "slack.assistant.greeting",
+  header: "",
+  defaultBody: "Hi! I'm your Agent Swarm assistant. How can I help?",
+  variables: [],
+  category: "system",
+});
+
+registerTemplate({
+  eventType: "slack.assistant.suggested_prompts",
+  header: "",
+  defaultBody: `Try these:
+- Check status: What's the current status of all agents?
+- Assign a task: Can you help me with...
+- List recent tasks: Show me the most recent tasks`,
+  variables: [],
+  category: "system",
+});
+
+registerTemplate({
+  eventType: "slack.assistant.offline",
+  header: "",
+  defaultBody:
+    "No agents are available right now. Your request has been queued and will be processed when agents come back online.",
+  variables: [],
+  category: "system",
+});
+
+registerTemplate({
+  eventType: "slack.message.thread_context",
+  header: "",
+  defaultBody: `<thread_context>
+{{thread_messages}}
+</thread_context>`,
+  variables: [
+    {
+      name: "thread_messages",
+      description: "Formatted thread messages (user: text pairs)",
+    },
+  ],
+  category: "system",
+});

package/src/slack/thread-buffer.ts

@@ -0,0 +1,213 @@
+import {
+  createTaskExtended,
+  getLatestActiveTaskInThread,
+  getLeadAgent,
+  getMostRecentTaskInThread,
+} from "../be/db";
+import { getSlackApp } from "./app";
+import { buildBufferFlushBlocks } from "./blocks";
+
+interface BufferedMessage {
+  text: string;
+  userId: string;
+  ts: string;
+}
+
+interface BufferedThread {
+  channelId: string;
+  threadTs: string;
+  messages: BufferedMessage[];
+  timer: Timer;
+  slackUserId: string; // original requester (first message sender)
+}
+
+const threadBuffers = new Map<string, BufferedThread>();
+
+const BUFFER_TIMEOUT_MS = Number(process.env.ADDITIVE_SLACK_BUFFER_MS) || 10_000;
+
+function makeKey(channelId: string, threadTs: string): string {
+  return `${channelId}:${threadTs}`;
+}
+
+/**
+ * Add a message to the thread buffer. Resets the debounce timer.
+ */
+export function bufferThreadMessage(
+  channelId: string,
+  threadTs: string,
+  text: string,
+  userId: string,
+  ts: string,
+): void {
+  const key = makeKey(channelId, threadTs);
+  const existing = threadBuffers.get(key);
+
+  if (existing) {
+    // Append to existing buffer, reset timer
+    existing.messages.push({ text, userId, ts });
+    clearTimeout(existing.timer);
+    existing.timer = setTimeout(() => flushBuffer(key, false), BUFFER_TIMEOUT_MS);
+    console.log(
+      `[Slack] Buffer append: ${key} (${existing.messages.length} messages, timer reset to ${BUFFER_TIMEOUT_MS}ms)`,
+    );
+  } else {
+    // Create new buffer entry
+    const timer = setTimeout(() => flushBuffer(key, false), BUFFER_TIMEOUT_MS);
+    threadBuffers.set(key, {
+      channelId,
+      threadTs,
+      messages: [{ text, userId, ts }],
+      timer,
+      slackUserId: userId,
+    });
+    console.log(`[Slack] Buffer created: ${key} (timer set to ${BUFFER_TIMEOUT_MS}ms)`);
+  }
+}
+
+/**
+ * Check if a thread currently has a pending buffer.
+ */
+export function isThreadBuffered(channelId: string, threadTs: string): boolean {
+  return threadBuffers.has(makeKey(channelId, threadTs));
+}
+
+/**
+ * Get the number of messages currently in the buffer for a thread key.
+ */
+export function getBufferMessageCount(key: string): number {
+  return threadBuffers.get(key)?.messages.length ?? 0;
+}
+
+/**
+ * Instantly flush the buffer (used by !now command). Clears the debounce timer
+ * and flushes with immediate=true (no dependsOn).
+ */
+export async function instantFlush(key: string): Promise<void> {
+  const buffer = threadBuffers.get(key);
+  if (buffer) {
+    clearTimeout(buffer.timer);
+    console.log(`[Slack] Instant flush triggered: ${key}`);
+  }
+  await flushBuffer(key, true);
+}
+
+/**
+ * Fetch thread context from Slack for the buffer flush task description.
+ */
+async function getThreadContextForBuffer(channelId: string, threadTs: string): Promise<string> {
+  const app = getSlackApp();
+  if (!app) return "";
+
+  try {
+    const result = await app.client.conversations.replies({
+      channel: channelId,
+      ts: threadTs,
+      limit: 20,
+    });
+
+    const messages = result.messages || [];
+    if (messages.length === 0) return "";
+
+    const formatted = messages
+      .filter((m) => m.text)
+      .map((m) => {
+        const msg = m as Record<string, unknown>;
+        const isBotMessage = msg.bot_id !== undefined || msg.subtype === "bot_message";
+        if (isBotMessage) {
+          const truncated = m.text && m.text.length > 500 ? `${m.text.slice(0, 500)}...` : m.text;
+          return `[Agent]: ${truncated}`;
+        }
+        return `<@${m.user}>: ${m.text}`;
+      })
+      .join("\n");
+
+    return formatted;
+  } catch (error) {
+    console.error("[Slack] Failed to fetch thread context for buffer:", error);
+    return "";
+  }
+}
+
+/**
+ * Flush the buffer: concatenate messages, create task with optional dependency chaining.
+ * @param key - The buffer key (channelId:threadTs)
+ * @param immediate - If true, skip dependency chaining (used by !now)
+ */
+async function flushBuffer(key: string, immediate = false): Promise<void> {
+  const buffer = threadBuffers.get(key);
+  if (!buffer || buffer.messages.length === 0) {
+    threadBuffers.delete(key);
+    return;
+  }
+
+  console.log(
+    `[Slack] Flushing buffer: ${key} (${buffer.messages.length} messages, immediate=${immediate})`,
+  );
+
+  // Build combined task description
+  const combinedText = buffer.messages.map((m) => m.text).join("\n---\n");
+  const description = `[Thread follow-up — ${buffer.messages.length} message(s) buffered]\n\n${combinedText}`;
+
+  // Find the latest active task in this thread for dependency chaining
+  const latestActiveTask = getLatestActiveTaskInThread(buffer.channelId, buffer.threadTs);
+  if (latestActiveTask) {
+    console.log(
+      `[Slack] Dependency chaining: latest active task ${latestActiveTask.id} (status: ${latestActiveTask.status})`,
+    );
+  }
+
+  const lead = getLeadAgent();
+
+  // Thread context for the task
+  const threadContext = await getThreadContextForBuffer(buffer.channelId, buffer.threadTs);
+  const fullDescription = threadContext
+    ? `<thread_context>\n${threadContext}\n</thread_context>\n\n${description}`
+    : description;
+
+  // Always pending. If !now was used (immediate=true), no dependency.
+  // Otherwise, depend on the latest active task so it queues naturally.
+  const dependsOn = !immediate && latestActiveTask ? [latestActiveTask.id] : undefined;
+
+  const mostRecentTask = getMostRecentTaskInThread(buffer.channelId, buffer.threadTs);
+  const task = createTaskExtended(fullDescription, {
+    agentId: lead?.id,
+    source: "slack",
+    slackChannelId: buffer.channelId,
+    slackThreadTs: buffer.threadTs,
+    slackUserId: buffer.slackUserId,
+    dependsOn,
+    parentTaskId: mostRecentTask?.id,
+  });
+
+  console.log(
+    `[Slack] Buffer flushed → task ${task.id} (dependsOn: ${dependsOn ? dependsOn.join(", ") : "none"})`,
+  );
+
+  // Slack feedback with Block Kit
+  const app = getSlackApp();
+  if (app) {
+    const hasDependency = !immediate && !!latestActiveTask;
+    const blocks = buildBufferFlushBlocks({
+      messageCount: buffer.messages.length,
+      taskId: task.id,
+      hasDependency,
+    });
+    const fallbackText = hasDependency
+      ? `${buffer.messages.length} follow-up message(s) queued pending completion of current task`
+      : `${buffer.messages.length} follow-up message(s) batched into task`;
+
+    try {
+      await app.client.chat.postMessage({
+        channel: buffer.channelId,
+        thread_ts: buffer.threadTs,
+        text: fallbackText,
+        // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
+        blocks: blocks as any,
+      });
+    } catch (error) {
+      console.error("[Slack] Failed to post buffer flush feedback:", error);
+    }
+  }
+
+  threadBuffers.delete(key);
+}

package/src/slack/watcher.ts

@@ -1,6 +1,11 @@
 import { getCompletedSlackTasks, getInProgressSlackTasks } from "../be/db";
 import { getSlackApp } from "./app";
-import { sendProgressUpdate, sendTaskResponse } from "./responses";
+import {
+  sendProgressUpdate,
+  sendTaskResponse,
+  updateProgressInPlace,
+  updateToFinal,
+} from "./responses";
 
 let watcherInterval: ReturnType<typeof setInterval> | null = null;
 let isProcessing = false;
@@ -18,6 +23,48 @@ const pendingSends = new Set<string>();
 const lastSendTime = new Map<string, number>();
 const MIN_SEND_INTERVAL = 1000; // Don't send for same task within 1 second
 
+// Track task message timestamps for chat.update (taskId -> message info)
+// This is THE message that evolves: assignment → progress → completion
+const taskMessages = new Map<string, { channelId: string; threadTs: string; messageTs: string }>();
+
+/**
+ * Register the initial message ts for a task (called by handlers.ts after posting assignment).
+ * This allows the watcher to update the same message through the task lifecycle.
+ */
+export function registerTaskMessage(
+  taskId: string,
+  channelId: string,
+  threadTs: string,
+  messageTs: string,
+): void {
+  taskMessages.set(taskId, { channelId, threadTs, messageTs });
+}
+
+/**
+ * Check if a channel is a DM (assistant thread). DM channels start with "D".
+ */
+function isDMChannel(channelId: string): boolean {
+  return channelId.startsWith("D");
+}
+
+/**
+ * Set the assistant thread status (typing indicator) for DM channels.
+ */
+async function setAssistantStatus(channelId: string, threadTs: string, status: string) {
+  const app = getSlackApp();
+  if (!app) return;
+
+  try {
+    await app.client.assistant.threads.setStatus({
+      channel_id: channelId,
+      thread_ts: threadTs,
+      status,
+    });
+  } catch (error) {
+    console.error(`[Slack] Failed to set assistant status:`, error);
+  }
+}
+
 /**
  * Start watching for Slack task updates and sending responses.
  */
@@ -52,6 +99,51 @@ export function startTaskWatcher(intervalMs = 3000): void {
         const lastSent = lastSendTime.get(progressKey);
         if (lastSent && now - lastSent < MIN_SEND_INTERVAL) continue;
 
+        const isDM = task.slackChannelId && isDMChannel(task.slackChannelId);
+
+        if (isDM && task.slackChannelId && task.slackThreadTs) {
+          // DM/assistant thread: use setStatus for typing indicator
+          const progressText = task.progress || "Processing your request...";
+          if (progressText !== sentProgress.get(task.id)) {
+            pendingSends.add(progressKey);
+            sentProgress.set(task.id, progressText);
+            lastSendTime.set(progressKey, now);
+            try {
+              await setAssistantStatus(task.slackChannelId, task.slackThreadTs, progressText);
+              console.log(`[Slack] Set assistant status for task ${task.id.slice(0, 8)}`);
+            } catch (error) {
+              sentProgress.delete(task.id);
+              lastSendTime.delete(progressKey);
+              console.error(`[Slack] Failed to set assistant status:`, error);
+            } finally {
+              pendingSends.delete(progressKey);
+            }
+          }
+          continue;
+        }
+
+        // Channel thread: use chat.update on the evolving message
+        const tracked = taskMessages.get(task.id);
+
+        // If we have a tracked message but haven't sent any progress yet,
+        // update assignment message to "In Progress" state immediately
+        if (tracked && !sentProgress.has(task.id) && !task.progress) {
+          pendingSends.add(progressKey);
+          sentProgress.set(task.id, "__in_progress__");
+          lastSendTime.set(progressKey, now);
+          try {
+            await updateProgressInPlace(task, "Starting...", tracked.messageTs);
+            console.log(`[Slack] Updated to in-progress for task ${task.id.slice(0, 8)}`);
+          } catch (error) {
+            sentProgress.delete(task.id);
+            lastSendTime.delete(progressKey);
+            console.error(`[Slack] Failed to update to in-progress:`, error);
+          } finally {
+            pendingSends.delete(progressKey);
+          }
+          continue;
+        }
+
         const lastSentProgress = sentProgress.get(task.id);
         // Only send if progress exists and is different from last sent
         if (task.progress && task.progress !== lastSentProgress) {
@@ -60,8 +152,23 @@ export function startTaskWatcher(intervalMs = 3000): void {
           sentProgress.set(task.id, task.progress);
           lastSendTime.set(progressKey, now);
           try {
-            await sendProgressUpdate(task, task.progress);
-            console.log(`[Slack] Sent progress update for task ${task.id.slice(0, 8)}`);
+            if (tracked) {
+              // Update the existing message in-place via chat.update
+              await updateProgressInPlace(task, task.progress, tracked.messageTs);
+              console.log(`[Slack] Updated progress in-place for task ${task.id.slice(0, 8)}`);
+            } else {
+              // No tracked message (e.g., multi-task assignment or server restart)
+              // Post a new progress message and track its ts
+              const messageTs = await sendProgressUpdate(task, task.progress);
+              if (messageTs && task.slackChannelId && task.slackThreadTs) {
+                taskMessages.set(task.id, {
+                  channelId: task.slackChannelId,
+                  threadTs: task.slackThreadTs,
+                  messageTs,
+                });
+              }
+              console.log(`[Slack] Sent initial progress for task ${task.id.slice(0, 8)}`);
+            }
           } catch (error) {
             // If send fails, clear markers so we can retry
             sentProgress.delete(task.id);
@@ -88,7 +195,15 @@ export function startTaskWatcher(intervalMs = 3000): void {
         notifiedCompletions.set(task.id, now);
         lastSendTime.set(completionKey, now);
         try {
-          await sendTaskResponse(task);
+          const tracked = taskMessages.get(task.id);
+          if (tracked) {
+            // Channel thread: update the same message to its final state
+            await updateToFinal(task, tracked.messageTs);
+            taskMessages.delete(task.id);
+          } else {
+            // DM or untracked: post completion as a new message
+            await sendTaskResponse(task);
+          }
           // Clean up progress tracking
           sentProgress.delete(task.id);
           console.log(`[Slack] Sent ${task.status} response for task ${task.id.slice(0, 8)}`);