@desplega.ai/agent-swarm 1.91.0 → 1.92.1

package/src/server.ts

@@ -78,6 +78,7 @@ import {
 import { registerScriptDeleteTool } from "./tools/script-delete";
 import { registerScriptQueryTypesTool } from "./tools/script-query-types";
 import { registerScriptRunTool } from "./tools/script-run";
+import { registerScriptRunsTools } from "./tools/script-runs";
 import { registerScriptSearchTool } from "./tools/script-search";
 import { registerScriptUpsertTool } from "./tools/script-upsert";
 import { registerSendTaskTool } from "./tools/send-task";
@@ -85,6 +86,7 @@ import { registerSendTaskTool } from "./tools/send-task";
 import {
   registerSkillCreateTool,
   registerSkillDeleteTool,
+  registerSkillGetFileTool,
   registerSkillGetTool,
   registerSkillInstallRemoteTool,
   registerSkillInstallTool,
@@ -227,6 +229,7 @@ export function createServer() {
   registerScriptUpsertTool(server);
   registerScriptDeleteTool(server);
   registerScriptQueryTypesTool(server);
+  registerScriptRunsTools(server);
 
   // External command routes - mirrors the `agent-swarm x ...` CLI surface.
   registerSwarmXTool(server);
@@ -327,6 +330,7 @@ export function createServer() {
   registerSkillUpdateTool(server);
   registerSkillDeleteTool(server);
   registerSkillGetTool(server);
+  registerSkillGetFileTool(server);
   registerSkillListTool(server);
   registerSkillSearchTool(server);
   registerSkillInstallTool(server);

package/src/slack/handlers.ts

@@ -18,6 +18,7 @@ import type { SlackFile } from "./files";
 import { extractTaskFromMessage, hasOtherUserMention, routeMessage } from "./router";
 // Side-effect import: registers all Slack event templates in the in-memory registry
 import "./templates";
+import { extractSlackMessageText } from "./message-text";
 import { bufferThreadMessage, getBufferMessageCount, instantFlush } from "./thread-buffer";
 import { registerTreeMessage } from "./watcher";
 
@@ -173,6 +174,8 @@ interface ThreadMessage {
   subtype?: string;
   text?: string;
   ts: string;
+  attachments?: Array<{ fallback?: string; text?: string; title?: string; pretext?: string }>;
+  blocks?: unknown[];
 }
 
 // Cache for bot's own user ID (avoids redundant auth.test calls)
@@ -286,8 +289,11 @@ async function getThreadContext(
     });
 
     const messages = (result.messages || []) as ThreadMessage[];
-    // Filter out the current message only (keep bot messages for context)
-    const previousMessages = messages.filter((m) => m.ts !== currentTs && m.text);
+    // Filter out the current message; include any message with extractable text
+    const previousMessages = messages.filter((m) => {
+      if (m.ts === currentTs) return false;
+      return extractSlackMessageText(m) !== "";
+    });
 
     if (previousMessages.length === 0) return "";
 
@@ -298,13 +304,14 @@ async function getThreadContext(
       const isBotMessage =
         m.user === botUserId || m.bot_id !== undefined || m.subtype === "bot_message";
 
+      const text = extractSlackMessageText(m);
       if (isBotMessage) {
         // Bot/agent message - truncate if too long
-        const truncatedText = m.text && m.text.length > 500 ? `${m.text.slice(0, 500)}...` : m.text;
+        const truncatedText = text.length > 500 ? `${text.slice(0, 500)}...` : text;
         formattedMessages.push(`[Agent]: ${truncatedText}`);
       } else {
         const userName = m.user ? await getUserDisplayName(client, m.user) : "Unknown";
-        formattedMessages.push(`${userName}: ${m.text}`);
+        formattedMessages.push(`${userName}: ${text}`);
       }
     }
 

package/src/slack/message-text.ts

@@ -0,0 +1,98 @@
+/**
+ * Shared utility for extracting displayable text from a Slack message.
+ *
+ * Slack integration/alert apps (Datadog, PagerDuty, GitHub) often post with
+ * an empty top-level `text` field and put all content in legacy `attachments`
+ * or Block Kit `blocks`. This helper falls back through those layers so callers
+ * never silently drop those messages.
+ */
+
+interface SlackAttachment {
+  fallback?: string;
+  text?: string;
+  title?: string;
+  pretext?: string;
+}
+
+// Internal shape used only inside the helper; callers pass `blocks?: unknown[]`
+interface SlackBlockInternal {
+  type?: string;
+  text?: { type?: string; text?: string };
+  /** section blocks may use fields[] instead of (or alongside) a top-level text object */
+  fields?: Array<{ type?: string; text?: string }>;
+  elements?: unknown[];
+}
+
+export interface SlackMessageLike {
+  text?: string;
+  attachments?: SlackAttachment[];
+  /** Typed as unknown[] so any Slack SDK block variant is accepted without casting. */
+  blocks?: unknown[];
+}
+
+/**
+ * Recursively collect plain text from a Slack rich_text node tree.
+ *
+ * Handles text leaf nodes plus all container types that carry child elements:
+ * rich_text_section, rich_text_list, rich_text_quote, rich_text_preformatted.
+ */
+function collectRichTextParts(node: unknown, parts: string[]): void {
+  if (node == null || typeof node !== "object") return;
+  const n = node as { type?: string; text?: string; elements?: unknown[] };
+  if (n.type === "text" && n.text) {
+    parts.push(n.text);
+  }
+  if (Array.isArray(n.elements)) {
+    for (const child of n.elements) {
+      collectRichTextParts(child, parts);
+    }
+  }
+}
+
+/**
+ * Return the best displayable text for a Slack message.
+ *
+ * Priority:
+ * 1. `msg.text` (non-empty)
+ * 2. `msg.attachments[]` — joins `fallback || text || title || pretext` for each
+ * 3. `msg.blocks[]` — extracts text from section (text + fields) and rich_text blocks
+ * 4. `""` if nothing found
+ */
+export function extractSlackMessageText(msg: SlackMessageLike): string {
+  if (msg.text?.trim()) return msg.text;
+
+  // Legacy attachments (Datadog, PagerDuty, GitHub alert apps)
+  if (Array.isArray(msg.attachments) && msg.attachments.length > 0) {
+    const parts = msg.attachments
+      .filter((a): a is SlackAttachment => a != null && typeof a === "object")
+      .map((a) => a.fallback || a.text || a.title || a.pretext || "")
+      .filter(Boolean);
+    if (parts.length > 0) return parts.join("\n");
+  }
+
+  // Block Kit blocks
+  if (Array.isArray(msg.blocks) && msg.blocks.length > 0) {
+    const parts: string[] = [];
+    for (const rawBlock of msg.blocks) {
+      if (rawBlock == null || typeof rawBlock !== "object") continue;
+      const block = rawBlock as SlackBlockInternal;
+      if (block.type === "section") {
+        if (block.text?.text) parts.push(block.text.text);
+        if (Array.isArray(block.fields)) {
+          for (const field of block.fields) {
+            if (field != null && typeof field === "object" && field.text) {
+              parts.push(field.text);
+            }
+          }
+        }
+      } else if (block.type === "rich_text" && Array.isArray(block.elements)) {
+        for (const el of block.elements) {
+          collectRichTextParts(el, parts);
+        }
+      }
+    }
+    if (parts.length > 0) return parts.join("\n");
+  }
+
+  return "";
+}

package/src/slack/thread-buffer.ts

@@ -4,6 +4,7 @@ import { slackContextKey } from "../tasks/context-key";
 import { createTaskWithSiblingAwareness } from "../tasks/sibling-awareness";
 import { getSlackApp } from "./app";
 import { buildBufferFlushBlocks } from "./blocks";
+import { extractSlackMessageText } from "./message-text";
 import { registerTreeMessage } from "./watcher";
 
 interface BufferedMessage {
@@ -93,15 +94,16 @@ async function getThreadContextForBuffer(channelId: string, threadTs: string): P
     if (messages.length === 0) return "";
 
     const formatted = messages
-      .filter((m) => m.text)
+      .filter((m) => extractSlackMessageText(m) !== "")
       .map((m) => {
         const msg = m as Record<string, unknown>;
         const isBotMessage = msg.bot_id !== undefined || msg.subtype === "bot_message";
+        const text = extractSlackMessageText(m);
         if (isBotMessage) {
-          const truncated = m.text && m.text.length > 500 ? `${m.text.slice(0, 500)}...` : m.text;
+          const truncated = text.length > 500 ? `${text.slice(0, 500)}...` : text;
           return `[Agent]: ${truncated}`;
         }
-        return `<@${m.user}>: ${m.text}`;
+        return `<@${m.user}>: ${text}`;
       })
       .join("\n");