@desplega.ai/agent-swarm 1.123.0 → 1.124.0

package/src/tools/slack-delete.ts

@@ -4,7 +4,7 @@ import { getAgentById } from "@/be/db";
 import { can } from "@/rbac";
 import { getSlackApp } from "@/slack/app";
 import { parseSlackTs } from "@/slack/message-text";
-import { createToolRegistrar } from "@/tools/utils";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
 export const registerSlackDeleteTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -24,25 +24,16 @@ export const registerSlackDeleteTool = (server: McpServer) => {
             "Timestamp of the message to delete. Accepts the dotted form (1783411554.596189), the 'p' deep-link form (p1783411554596189), or a full Slack permalink URL.",
           ),
       }),
-      outputSchema: z.object({
-        success: z.boolean(),
-        message: z.string(),
-      }),
+      outputSchema: swarmToolOutputSchema(),
     },
     async ({ channelId, messageTs }, requestInfo, _meta) => {
       if (!requestInfo.agentId) {
-        return {
-          content: [{ type: "text", text: "Agent ID not found." }],
-          structuredContent: { success: false, message: "Agent ID not found." },
-        };
+        return toolErr("Agent ID not found.");
       }
 
       const agent = getAgentById(requestInfo.agentId);
       if (!agent) {
-        return {
-          content: [{ type: "text", text: "Agent not found." }],
-          structuredContent: { success: false, message: "Agent not found." },
-        };
+        return toolErr("Agent not found.");
       }
 
       const decision = can({
@@ -52,31 +43,19 @@ export const registerSlackDeleteTool = (server: McpServer) => {
         source: "mcp",
       });
       if (!decision.allow) {
-        return {
-          content: [{ type: "text", text: "Deleting Slack messages requires lead privileges." }],
-          structuredContent: {
-            success: false,
-            message: "Deleting Slack messages requires lead privileges.",
-          },
-        };
+        return toolErr("Deleting Slack messages requires lead privileges.");
       }
 
       const app = getSlackApp();
       if (!app) {
-        return {
-          content: [{ type: "text", text: "Slack not configured." }],
-          structuredContent: { success: false, message: "Slack not configured." },
-        };
+        return toolErr("Slack not configured.");
       }
 
       try {
         const ts = parseSlackTs(messageTs);
         await app.client.chat.delete({ channel: channelId, ts });
 
-        return {
-          content: [{ type: "text", text: "Message deleted successfully." }],
-          structuredContent: { success: true, message: "Message deleted successfully." },
-        };
+        return toolOk("Message deleted successfully.");
       } catch (error) {
         const errorCode = (error as { data?: { error?: string } } | undefined)?.data?.error;
         const errorMsg = error instanceof Error ? error.message : String(error);
@@ -99,10 +78,7 @@ export const registerSlackDeleteTool = (server: McpServer) => {
             message = `Failed to delete message: ${errorMsg}`;
         }
 
-        return {
-          content: [{ type: "text", text: message }],
-          structuredContent: { success: false, message },
-        };
+        return toolErr(message);
       }
     },
   );

package/src/tools/slack-download-file.ts

@@ -3,7 +3,7 @@ import * as z from "zod";
 import { getAgentById } from "@/be/db";
 import { getSlackApp } from "@/slack/app";
 import { DEFAULT_DOWNLOAD_DIR, downloadFile, getFileInfo } from "@/slack/files";
-import { createToolRegistrar } from "@/tools/utils";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
 export const registerSlackDownloadFileTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -35,58 +35,41 @@ export const registerSlackDownloadFileTool = (server: McpServer) => {
           .optional()
           .describe("Filename to use when saving. Only used if savePath is a directory."),
       }),
-      outputSchema: z.object({
-        success: z.boolean(),
-        message: z.string(),
+      outputSchema: swarmToolOutputSchema({
         savedPath: z.string().optional(),
         fileInfo: z
-          .object({
-            id: z.string(),
-            name: z.string(),
-            mimetype: z.string(),
-            size: z.number(),
+          .looseObject({
+            id: z.string().optional(),
+            name: z.string().optional(),
+            mimetype: z.string().optional(),
+            size: z.number().optional(),
           })
           .optional(),
       }),
     },
     async ({ fileId, url, savePath, filename }, requestInfo, _meta) => {
       if (!requestInfo.agentId) {
-        return {
-          content: [{ type: "text", text: "Agent ID not found." }],
-          structuredContent: { success: false, message: "Agent ID not found." },
-        };
+        return toolErr("Agent ID not found.");
       }
 
       const agent = getAgentById(requestInfo.agentId);
       if (!agent) {
-        return {
-          content: [{ type: "text", text: "Agent not found." }],
-          structuredContent: { success: false, message: "Agent not found." },
-        };
+        return toolErr("Agent not found.");
       }
 
       // Must provide either fileId or url
       if (!fileId && !url) {
-        return {
-          content: [{ type: "text", text: "Must provide either fileId or url." }],
-          structuredContent: { success: false, message: "Must provide either fileId or url." },
-        };
+        return toolErr("Must provide either fileId or url.");
       }
 
       const app = getSlackApp();
       if (!app) {
-        return {
-          content: [{ type: "text", text: "Slack not configured." }],
-          structuredContent: { success: false, message: "Slack not configured." },
-        };
+        return toolErr("Slack not configured.");
       }
 
       const token = process.env.SLACK_BOT_TOKEN;
       if (!token) {
-        return {
-          content: [{ type: "text", text: "Slack bot token not configured." }],
-          structuredContent: { success: false, message: "Slack bot token not configured." },
-        };
+        return toolErr("Slack bot token not configured.");
       }
 
       try {
@@ -104,10 +87,7 @@ export const registerSlackDownloadFileTool = (server: McpServer) => {
         if (fileId) {
           const info = await getFileInfo(app.client, fileId);
           if (!info) {
-            return {
-              content: [{ type: "text", text: `File not found: ${fileId}` }],
-              structuredContent: { success: false, message: `File not found: ${fileId}` },
-            };
+            return toolErr(`File not found: ${fileId}`);
           }
 
           downloadUrl = info.url_private_download;
@@ -120,10 +100,7 @@ export const registerSlackDownloadFileTool = (server: McpServer) => {
         }
 
         if (!downloadUrl) {
-          return {
-            content: [{ type: "text", text: "No download URL available." }],
-            structuredContent: { success: false, message: "No download URL available." },
-          };
+          return toolErr("No download URL available.");
         }
 
         // Determine save path
@@ -145,31 +122,14 @@ export const registerSlackDownloadFileTool = (server: McpServer) => {
         });
 
         if (!result.success) {
-          return {
-            content: [{ type: "text", text: `Failed to download file: ${result.error}` }],
-            structuredContent: {
-              success: false,
-              message: `Failed to download file: ${result.error}`,
-            },
-          };
+          return toolErr(`Failed to download file: ${result.error}`);
         }
 
         const successMsg = `File downloaded successfully to ${result.savedPath}`;
-        return {
-          content: [{ type: "text", text: successMsg }],
-          structuredContent: {
-            success: true,
-            message: successMsg,
-            savedPath: result.savedPath,
-            fileInfo,
-          },
-        };
+        return toolOk(successMsg, { data: { savedPath: result.savedPath, fileInfo } });
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        return {
-          content: [{ type: "text", text: `Failed to download file: ${errorMsg}` }],
-          structuredContent: { success: false, message: `Failed to download file: ${errorMsg}` },
-        };
+        return toolErr(`Failed to download file: ${errorMsg}`);
       }
     },
   );

package/src/tools/slack-list-channels.ts

@@ -2,13 +2,13 @@ import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import { getAgentById } from "@/be/db";
 import { getSlackApp } from "@/slack/app";
-import { createToolRegistrar } from "@/tools/utils";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
-const SlackChannelSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  type: z.enum(["public", "private", "dm", "mpim"]),
-  isMember: z.boolean(),
+const SlackChannelSchema = z.looseObject({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  type: z.enum(["public", "private", "dm", "mpim"]).optional(),
+  isMember: z.boolean().optional(),
   numMembers: z.number().optional(),
 });
 
@@ -36,34 +36,23 @@ export const registerSlackListChannelsTool = (server: McpServer) => {
           .default(100)
           .describe("Maximum number of channels to retrieve (default: 100, max: 200)."),
       }),
-      outputSchema: z.object({
-        success: z.boolean(),
-        message: z.string(),
-        channels: z.array(SlackChannelSchema),
+      outputSchema: swarmToolOutputSchema({
+        channels: z.array(SlackChannelSchema).optional(),
       }),
     },
     async ({ types, limit = 100 }, requestInfo, _meta) => {
       if (!requestInfo.agentId) {
-        return {
-          content: [{ type: "text", text: "Agent ID not found." }],
-          structuredContent: { success: false, message: "Agent ID not found.", channels: [] },
-        };
+        return toolErr("Agent ID not found.", { data: { channels: [] } });
       }
 
       const agent = getAgentById(requestInfo.agentId);
       if (!agent) {
-        return {
-          content: [{ type: "text", text: "Agent not found." }],
-          structuredContent: { success: false, message: "Agent not found.", channels: [] },
-        };
+        return toolErr("Agent not found.", { data: { channels: [] } });
       }
 
       const app = getSlackApp();
       if (!app) {
-        return {
-          content: [{ type: "text", text: "Slack not configured." }],
-          structuredContent: { success: false, message: "Slack not configured.", channels: [] },
-        };
+        return toolErr("Slack not configured.", { data: { channels: [] } });
       }
 
       try {
@@ -141,29 +130,13 @@ export const registerSlackListChannelsTool = (server: McpServer) => {
           })
           .join("\n");
 
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Found ${channels.length} channel(s):\n\n${textOutput}`,
-            },
-          ],
-          structuredContent: {
-            success: true,
-            message: `Found ${channels.length} channel(s).`,
-            channels,
-          },
-        };
+        return toolOk(`Found ${channels.length} channel(s).`, {
+          details: textOutput || undefined,
+          data: { channels },
+        });
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        return {
-          content: [{ type: "text", text: `Failed to list Slack channels: ${errorMsg}` }],
-          structuredContent: {
-            success: false,
-            message: `Failed to list Slack channels: ${errorMsg}`,
-            channels: [],
-          },
-        };
+        return toolErr(`Failed to list Slack channels: ${errorMsg}`, { data: { channels: [] } });
       }
     },
   );

package/src/tools/slack-post.ts

@@ -5,7 +5,7 @@ import { can } from "@/rbac";
 import { getSlackApp } from "@/slack/app";
 import { withAutoJoin } from "@/slack/channel-join";
 import { markdownToSlack } from "@/slack/responses";
-import { createToolRegistrar } from "@/tools/utils";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
 export const registerSlackPostTool = (server: McpServer) => {
   createToolRegistrar(server)(
@@ -26,26 +26,18 @@ export const registerSlackPostTool = (server: McpServer) => {
             "Optional parent message ts to thread under. Obtain via `slack-start-thread`. When omitted, posts as a new top-level message.",
           ),
       }),
-      outputSchema: z.object({
-        success: z.boolean(),
-        message: z.string(),
+      outputSchema: swarmToolOutputSchema({
         messageTs: z.string().optional(),
       }),
     },
     async ({ channelId, message, threadTs }, requestInfo, _meta) => {
       if (!requestInfo.agentId) {
-        return {
-          content: [{ type: "text", text: "Agent ID not found." }],
-          structuredContent: { success: false, message: "Agent ID not found." },
-        };
+        return toolErr("Agent ID not found.");
       }
 
       const agent = getAgentById(requestInfo.agentId);
       if (!agent) {
-        return {
-          content: [{ type: "text", text: "Agent not found." }],
-          structuredContent: { success: false, message: "Agent not found." },
-        };
+        return toolErr("Agent not found.");
       }
 
       // Require lead privileges to post directly to channels
@@ -56,21 +48,12 @@ export const registerSlackPostTool = (server: McpServer) => {
         source: "mcp",
       });
       if (!decision.allow) {
-        return {
-          content: [{ type: "text", text: "Posting to Slack channels requires lead privileges." }],
-          structuredContent: {
-            success: false,
-            message: "Posting to Slack channels requires lead privileges.",
-          },
-        };
+        return toolErr("Posting to Slack channels requires lead privileges.");
       }
 
       const app = getSlackApp();
       if (!app) {
-        return {
-          content: [{ type: "text", text: "Slack not configured." }],
-          structuredContent: { success: false, message: "Slack not configured." },
-        };
+        return toolErr("Slack not configured.");
       }
 
       try {
@@ -97,25 +80,13 @@ export const registerSlackPostTool = (server: McpServer) => {
 
         const messageTs = result.ts;
 
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Message posted successfully.${messageTs ? ` Message timestamp: ${messageTs}` : ""}`,
-            },
-          ],
-          structuredContent: {
-            success: true,
-            message: "Message posted successfully.",
-            messageTs,
-          },
-        };
+        return toolOk("Message posted successfully.", {
+          details: messageTs ? `Message timestamp: ${messageTs}` : undefined,
+          data: { messageTs },
+        });
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        return {
-          content: [{ type: "text", text: `Failed to post message: ${errorMsg}` }],
-          structuredContent: { success: false, message: `Failed to post message: ${errorMsg}` },
-        };
+        return toolErr(`Failed to post message: ${errorMsg}`);
       }
     },
   );

package/src/tools/slack-read.ts

@@ -6,7 +6,7 @@ import { getSlackApp } from "@/slack/app";
 import { withAutoJoin } from "@/slack/channel-join";
 import { downloadFile } from "@/slack/files";
 import { extractSlackMessageText } from "@/slack/message-text";
-import { createToolRegistrar } from "@/tools/utils";
+import { createToolRegistrar, swarmToolOutputSchema, toolErr, toolOk } from "@/tools/utils";
 
 /**
  * Default download directory for auto-downloaded Slack files (inside MCP container).
@@ -14,22 +14,22 @@ import { createToolRegistrar } from "@/tools/utils";
  */
 const AUTO_DOWNLOAD_DIR = "/app/shared/downloads/slack";
 
-const SlackFileSchema = z.object({
-  id: z.string(),
-  name: z.string(),
-  mimetype: z.string(),
-  filetype: z.string(),
-  size: z.number(),
-  url_private_download: z.string(),
+const SlackFileSchema = z.looseObject({
+  id: z.string().optional(),
+  name: z.string().optional(),
+  mimetype: z.string().optional(),
+  filetype: z.string().optional(),
+  size: z.number().optional(),
+  url_private_download: z.string().optional(),
   localPath: z.string().optional(),
 });
 
-const SlackMessageSchema = z.object({
+const SlackMessageSchema = z.looseObject({
   user: z.string().optional(),
   username: z.string().optional(),
-  isBot: z.boolean(),
-  text: z.string(),
-  ts: z.string(),
+  isBot: z.boolean().optional(),
+  text: z.string().optional(),
+  ts: z.string().optional(),
   files: z.array(SlackFileSchema).optional(),
 });
 
@@ -65,12 +65,10 @@ export const registerSlackReadTool = (server: McpServer) => {
           .default(true)
           .describe("Include file attachments in the response (default: true)."),
       }),
-      outputSchema: z.object({
-        success: z.boolean(),
-        message: z.string(),
+      outputSchema: swarmToolOutputSchema({
         channelId: z.string().optional(),
         threadTs: z.string().optional(),
-        messages: z.array(SlackMessageSchema),
+        messages: z.array(SlackMessageSchema).optional(),
       }),
     },
     async (
@@ -79,18 +77,12 @@ export const registerSlackReadTool = (server: McpServer) => {
       _meta,
     ) => {
       if (!requestInfo.agentId) {
-        return {
-          content: [{ type: "text", text: "Agent ID not found." }],
-          structuredContent: { success: false, message: "Agent ID not found.", messages: [] },
-        };
+        return toolErr("Agent ID not found.", { data: { messages: [] } });
       }
 
       const agent = getAgentById(requestInfo.agentId);
       if (!agent) {
-        return {
-          content: [{ type: "text", text: "Agent not found." }],
-          structuredContent: { success: false, message: "Agent not found.", messages: [] },
-        };
+        return toolErr("Agent not found.", { data: { messages: [] } });
       }
 
       let slackChannelId: string | undefined = channelId;
@@ -100,45 +92,21 @@ export const registerSlackReadTool = (server: McpServer) => {
       if (inboxMessageId) {
         const inboxMsg = getInboxMessageById(inboxMessageId);
         if (!inboxMsg) {
-          return {
-            content: [{ type: "text", text: "Inbox message not found." }],
-            structuredContent: {
-              success: false,
-              message: "Inbox message not found.",
-              messages: [],
-            },
-          };
+          return toolErr("Inbox message not found.", { data: { messages: [] } });
         }
         if (inboxMsg.agentId !== requestInfo.agentId) {
-          return {
-            content: [{ type: "text", text: "This inbox message is not yours." }],
-            structuredContent: {
-              success: false,
-              message: "This inbox message is not yours.",
-              messages: [],
-            },
-          };
+          return toolErr("This inbox message is not yours.", { data: { messages: [] } });
         }
         slackChannelId = inboxMsg.slackChannelId;
         slackThreadTs = inboxMsg.slackThreadTs;
       } else if (taskId) {
         const task = getTaskById(taskId);
         if (!task) {
-          return {
-            content: [{ type: "text", text: "Task not found." }],
-            structuredContent: { success: false, message: "Task not found.", messages: [] },
-          };
+          return toolErr("Task not found.", { data: { messages: [] } });
         }
         // Verify agent has context for this task
         if (task.agentId !== requestInfo.agentId && task.creatorAgentId !== requestInfo.agentId) {
-          return {
-            content: [{ type: "text", text: "You don't have context for this task." }],
-            structuredContent: {
-              success: false,
-              message: "You don't have context for this task.",
-              messages: [],
-            },
-          };
+          return toolErr("You don't have context for this task.", { data: { messages: [] } });
         }
         slackChannelId = task.slackChannelId;
         slackThreadTs = task.slackThreadTs;
@@ -151,45 +119,25 @@ export const registerSlackReadTool = (server: McpServer) => {
           source: "mcp",
         });
         if (!decision.allow) {
-          return {
-            content: [{ type: "text", text: "Direct channel access requires lead privileges." }],
-            structuredContent: {
-              success: false,
-              message: "Direct channel access requires lead privileges.",
-              messages: [],
-            },
-          };
+          return toolErr("Direct channel access requires lead privileges.", {
+            data: { messages: [] },
+          });
         }
         slackChannelId = channelId;
         slackThreadTs = threadTs;
       } else {
-        return {
-          content: [{ type: "text", text: "Must provide inboxMessageId, taskId, or channelId." }],
-          structuredContent: {
-            success: false,
-            message: "Must provide inboxMessageId, taskId, or channelId.",
-            messages: [],
-          },
-        };
+        return toolErr("Must provide inboxMessageId, taskId, or channelId.", {
+          data: { messages: [] },
+        });
       }
 
       if (!slackChannelId) {
-        return {
-          content: [{ type: "text", text: "No Slack channel context available." }],
-          structuredContent: {
-            success: false,
-            message: "No Slack channel context available.",
-            messages: [],
-          },
-        };
+        return toolErr("No Slack channel context available.", { data: { messages: [] } });
       }
 
       const app = getSlackApp();
       if (!app) {
-        return {
-          content: [{ type: "text", text: "Slack not configured." }],
-          structuredContent: { success: false, message: "Slack not configured.", messages: [] },
-        };
+        return toolErr("Slack not configured.", { data: { messages: [] } });
       }
 
       try {
@@ -370,31 +318,13 @@ export const registerSlackReadTool = (server: McpServer) => {
           })
           .join("\n\n");
 
-        return {
-          content: [
-            {
-              type: "text",
-              text: `Retrieved ${messages.length} message(s) from Slack.\n\n${textOutput}`,
-            },
-          ],
-          structuredContent: {
-            success: true,
-            message: `Retrieved ${messages.length} message(s).`,
-            channelId: slackChannelId,
-            threadTs: slackThreadTs,
-            messages,
-          },
-        };
+        return toolOk(`Retrieved ${messages.length} message(s).`, {
+          details: textOutput || undefined,
+          data: { channelId: slackChannelId, threadTs: slackThreadTs, messages },
+        });
       } catch (error) {
         const errorMsg = error instanceof Error ? error.message : String(error);
-        return {
-          content: [{ type: "text", text: `Failed to read Slack messages: ${errorMsg}` }],
-          structuredContent: {
-            success: false,
-            message: `Failed to read Slack messages: ${errorMsg}`,
-            messages: [],
-          },
-        };
+        return toolErr(`Failed to read Slack messages: ${errorMsg}`, { data: { messages: [] } });
       }
     },
   );