@desplega.ai/agent-swarm 1.51.2 → 1.52.1

package/src/tests/tool-registrar-no-input.test.ts

@@ -0,0 +1,114 @@
+import { describe, expect, test } from "bun:test";
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createToolRegistrar } from "../tools/utils";
+
+describe("createToolRegistrar with no inputSchema", () => {
+  test("handler receives requestInfo from meta when no inputSchema is defined", async () => {
+    const server = new McpServer({ name: "test-no-input", version: "1.0.0" });
+
+    let receivedRequestInfo: unknown = null;
+    let receivedMeta: unknown = null;
+
+    createToolRegistrar(server)(
+      "test-no-input-tool",
+      {
+        title: "Test Tool",
+        description: "Tool with no inputSchema",
+        outputSchema: z.object({ ok: z.boolean() }),
+      },
+      async (requestInfo, meta) => {
+        receivedRequestInfo = requestInfo;
+        receivedMeta = meta;
+        return {
+          content: [{ type: "text" as const, text: "ok" }],
+          structuredContent: { ok: true },
+        };
+      },
+    );
+
+    // Access the internal registered tool handler directly
+    // The MCP SDK stores tools in _registeredTools and calls handler(extra) for no-inputSchema
+    const registeredTools = (server as Record<string, unknown>)._registeredTools as Record<
+      string,
+      { handler: (extra: unknown) => Promise<unknown> }
+    >;
+
+    const tool = registeredTools["test-no-input-tool"];
+    expect(tool).toBeDefined();
+
+    // Simulate how the MCP SDK calls the handler for tools without inputSchema:
+    // It calls handler(extra) with a single argument (the Meta/extra object)
+    const fakeExtra = {
+      sessionId: "test-session-123",
+      requestInfo: {
+        headers: {
+          "x-agent-id": "agent-abc",
+          "x-source-task-id": "task-xyz",
+        },
+      },
+    };
+
+    // This is the critical test: the handler should NOT throw
+    // Before the fix, this would throw "undefined is not an object (evaluating 'req.requestInfo')"
+    const result = await tool.handler(fakeExtra);
+
+    expect(receivedRequestInfo).toEqual({
+      sessionId: "test-session-123",
+      agentId: "agent-abc",
+      sourceTaskId: "task-xyz",
+    });
+    expect(receivedMeta).toBe(fakeExtra);
+    expect(result).toBeDefined();
+  });
+
+  test("handler with inputSchema still receives args correctly", async () => {
+    const server = new McpServer({ name: "test-with-input", version: "1.0.0" });
+
+    let receivedArgs: unknown = null;
+    let receivedRequestInfo: unknown = null;
+
+    createToolRegistrar(server)(
+      "test-with-input-tool",
+      {
+        title: "Test Tool With Input",
+        description: "Tool with inputSchema",
+        inputSchema: z.object({ name: z.string() }),
+        outputSchema: z.object({ greeting: z.string() }),
+      },
+      async (args, requestInfo, _meta) => {
+        receivedArgs = args;
+        receivedRequestInfo = requestInfo;
+        return {
+          content: [{ type: "text" as const, text: "ok" }],
+          structuredContent: { greeting: `Hello ${args.name}` },
+        };
+      },
+    );
+
+    const registeredTools = (server as Record<string, unknown>)._registeredTools as Record<
+      string,
+      { handler: (args: unknown, extra: unknown) => Promise<unknown> }
+    >;
+
+    const tool = registeredTools["test-with-input-tool"];
+
+    // MCP SDK calls handler(args, extra) when inputSchema is defined
+    const fakeExtra = {
+      sessionId: "test-session-456",
+      requestInfo: {
+        headers: { "x-agent-id": "agent-def" },
+      },
+    };
+
+    const result = await tool.handler({ name: "World" }, fakeExtra);
+
+    expect(receivedArgs).toEqual({ name: "World" });
+    expect(receivedRequestInfo).toEqual({
+      sessionId: "test-session-456",
+      agentId: "agent-def",
+      sourceTaskId: undefined,
+    });
+    expect(result).toBeDefined();
+  });
+});

package/src/tests/update-profile-auth.test.ts

@@ -28,6 +28,7 @@ async function callUpdateProfile(
   callerAgentId: string | undefined,
   args: Record<string, unknown>,
 ): Promise<{ structuredContent: StructuredContent }> {
+  // biome-ignore lint/complexity/noBannedTypes: accessing internal MCP SDK type for test
   const tools = (server as unknown as { _registeredTools: Record<string, { handler: Function }> })
     ._registeredTools;
   const handler = tools["update-profile"].handler;

package/src/tests/workflow-executors.test.ts

@@ -690,7 +690,7 @@ describe("ValidateExecutor", () => {
 // ─── Registry Wiring ─────────────────────────────────────────
 
 describe("createExecutorRegistry", () => {
-  test("registers all 8 executors (7 instant + 1 async)", () => {
+  test("registers all 9 executors (7 instant + 2 async)", () => {
     const registry = createExecutorRegistry(mockDeps);
     const types = registry.types();
 
@@ -702,7 +702,8 @@ describe("createExecutorRegistry", () => {
     expect(types).toContain("vcs");
     expect(types).toContain("validate");
     expect(types).toContain("agent-task");
-    expect(types).toHaveLength(8);
+    expect(types).toContain("human-in-the-loop");
+    expect(types).toHaveLength(9);
   });
 
   test("instant executors have mode instant, async executors have mode async", () => {
@@ -720,6 +721,7 @@ describe("createExecutorRegistry", () => {
       expect(registry.get(type).mode).toBe("instant");
     }
     expect(registry.get("agent-task").mode).toBe("async");
+    expect(registry.get("human-in-the-loop").mode).toBe("async");
   });
 
   test("get() retrieves the correct executor by type", () => {

package/src/tools/request-human-input.ts

@@ -0,0 +1,117 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createApprovalRequest, getAgentCurrentTask } from "@/be/db";
+import { createToolRegistrar } from "@/tools/utils";
+
+const QuestionSchema = z.object({
+  id: z.string().describe("Unique ID for the question (used as key in responses)"),
+  type: z
+    .enum(["approval", "text", "single-select", "multi-select", "boolean"])
+    .describe("Question type"),
+  label: z.string().describe("The question text displayed to the user"),
+  required: z.boolean().optional().describe("Whether this question is required (default: true)"),
+  description: z.string().optional().describe("Optional help text"),
+  placeholder: z.string().optional().describe("Placeholder text (for text type)"),
+  multiline: z.boolean().optional().describe("Use textarea instead of input (for text type)"),
+  options: z
+    .array(
+      z.object({
+        value: z.string(),
+        label: z.string(),
+        description: z.string().optional(),
+      }),
+    )
+    .optional()
+    .describe("Options (for single-select/multi-select types)"),
+  minSelections: z.number().int().min(0).optional().describe("Min selections (for multi-select)"),
+  maxSelections: z.number().int().min(1).optional().describe("Max selections (for multi-select)"),
+  defaultValue: z.boolean().optional().describe("Default value (for boolean type)"),
+});
+
+export const registerRequestHumanInputTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "request-human-input",
+    {
+      title: "Request human input",
+      annotations: { destructiveHint: false },
+      description:
+        "Create an approval request that pauses until a human responds. " +
+        "Supports multiple question types: approval (yes/no), text, single-select, " +
+        "multi-select, and boolean. Returns the request ID and URL for the human to respond.",
+      inputSchema: z.object({
+        title: z.string().min(1).describe("Title of the approval request"),
+        questions: z.array(QuestionSchema).min(1).describe("Questions to ask the human"),
+        timeoutSeconds: z
+          .number()
+          .int()
+          .min(1)
+          .optional()
+          .describe("Timeout in seconds (auto-rejects on timeout)"),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+        requestId: z.string().uuid().optional(),
+        url: z.string().optional(),
+      }),
+    },
+    async ({ title, questions, timeoutSeconds }, requestInfo) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [
+            {
+              type: "text",
+              text: 'Agent ID not found. The MCP client should define the "X-Agent-ID" header.',
+            },
+          ],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: 'Agent ID not found. The MCP client should define the "X-Agent-ID" header.',
+          },
+        };
+      }
+
+      // Resolve sourceTaskId: prefer header, fall back to agent's current in-progress task.
+      // The X-Source-Task-Id header may be missing when the per-session MCP config wasn't
+      // created (e.g. .mcp.json not found, session resumed, or lead agent on a non-task trigger).
+      let sourceTaskId = requestInfo.sourceTaskId;
+      if (!sourceTaskId && requestInfo.agentId) {
+        const currentTask = getAgentCurrentTask(requestInfo.agentId);
+        if (currentTask) {
+          sourceTaskId = currentTask.id;
+        }
+      }
+
+      const id = crypto.randomUUID();
+      const request = createApprovalRequest({
+        id,
+        title,
+        questions,
+        approvers: { policy: "any" },
+        sourceTaskId: sourceTaskId ?? undefined,
+        timeoutSeconds,
+      });
+
+      const appUrl = process.env.APP_URL || "http://localhost:5274";
+      const url = `${appUrl}/approval-requests/${request.id}`;
+
+      return {
+        content: [
+          {
+            type: "text",
+            text: `Created approval request "${id}". Human can respond at: ${url}`,
+          },
+        ],
+        structuredContent: {
+          yourAgentId: requestInfo.agentId,
+          success: true,
+          message: `Approval request created. Respond at: ${url}`,
+          requestId: request.id,
+          url,
+        },
+      };
+    },
+  );
+};

package/src/tools/skills/index.ts

@@ -0,0 +1,11 @@
+export { registerSkillCreateTool } from "./skill-create";
+export { registerSkillDeleteTool } from "./skill-delete";
+export { registerSkillGetTool } from "./skill-get";
+export { registerSkillInstallTool } from "./skill-install";
+export { registerSkillInstallRemoteTool } from "./skill-install-remote";
+export { registerSkillListTool } from "./skill-list";
+export { registerSkillPublishTool } from "./skill-publish";
+export { registerSkillSearchTool } from "./skill-search";
+export { registerSkillSyncRemoteTool } from "./skill-sync-remote";
+export { registerSkillUninstallTool } from "./skill-uninstall";
+export { registerSkillUpdateTool } from "./skill-update";

package/src/tools/skills/skill-create.ts

@@ -0,0 +1,105 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createSkill, getAgentById, installSkill } from "@/be/db";
+import { parseSkillContent } from "@/be/skill-parser";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerSkillCreateTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "skill-create",
+    {
+      title: "Create Skill",
+      annotations: { destructiveHint: false },
+      description:
+        "Create a personal skill from SKILL.md content. Parses frontmatter for name, description, and metadata.",
+      inputSchema: z.object({
+        content: z
+          .string()
+          .min(1)
+          .describe("Full SKILL.md content (YAML frontmatter + markdown body)"),
+        scope: z
+          .enum(["agent", "swarm"])
+          .default("agent")
+          .optional()
+          .describe("Scope: agent (personal) or swarm (shared). Default: agent"),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+        skill: z.any().optional(),
+      }),
+    },
+    async (args, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: "Agent ID not found." }],
+          structuredContent: { success: false, message: "Agent ID not found." },
+        };
+      }
+
+      try {
+        const parsed = parseSkillContent(args.content);
+
+        // If swarm scope requested, only leads can create directly
+        if (args.scope === "swarm") {
+          const agent = getAgentById(requestInfo.agentId);
+          if (!agent?.isLead) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: 'Only lead agents can create swarm-scope skills directly. Use "skill-publish" to request approval.',
+                },
+              ],
+              structuredContent: {
+                yourAgentId: requestInfo.agentId,
+                success: false,
+                message: "Only lead agents can create swarm-scope skills directly.",
+              },
+            };
+          }
+        }
+
+        const skill = createSkill({
+          name: parsed.name,
+          description: parsed.description,
+          content: args.content,
+          type: "personal",
+          scope: args.scope ?? "agent",
+          ownerAgentId: requestInfo.agentId,
+          allowedTools: parsed.allowedTools,
+          model: parsed.model,
+          effort: parsed.effort,
+          context: parsed.context,
+          agent: parsed.agent,
+          disableModelInvocation: parsed.disableModelInvocation,
+          userInvocable: parsed.userInvocable,
+        });
+
+        // Auto-install for the creating agent
+        installSkill(requestInfo.agentId, skill.id);
+
+        return {
+          content: [{ type: "text", text: `Created skill "${skill.name}" (${skill.id})` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message: `Created and installed skill "${skill.name}".`,
+            skill,
+          },
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Failed to create skill: ${message}` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `Failed: ${message}`,
+          },
+        };
+      }
+    },
+  );
+};

package/src/tools/skills/skill-delete.ts

@@ -0,0 +1,67 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { deleteSkill, getAgentById, getSkillById } from "@/be/db";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerSkillDeleteTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "skill-delete",
+    {
+      title: "Delete Skill",
+      annotations: { destructiveHint: true },
+      description: "Delete a skill. Only the owning agent or lead can delete.",
+      inputSchema: z.object({
+        skillId: z.string().describe("ID of the skill to delete"),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+      }),
+    },
+    async (args, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: "Agent ID not found." }],
+          structuredContent: { success: false, message: "Agent ID not found." },
+        };
+      }
+
+      const existing = getSkillById(args.skillId);
+      if (!existing) {
+        return {
+          content: [{ type: "text", text: "Skill not found." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "Skill not found.",
+          },
+        };
+      }
+
+      const agent = getAgentById(requestInfo.agentId);
+      if (existing.ownerAgentId !== requestInfo.agentId && !agent?.isLead) {
+        return {
+          content: [{ type: "text", text: "Only the owning agent or lead can delete this skill." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "Permission denied.",
+          },
+        };
+      }
+
+      const deleted = deleteSkill(args.skillId);
+      return {
+        content: [
+          { type: "text", text: deleted ? `Deleted skill "${existing.name}".` : "Delete failed." },
+        ],
+        structuredContent: {
+          yourAgentId: requestInfo.agentId,
+          success: deleted,
+          message: deleted ? `Deleted skill "${existing.name}".` : "Delete failed.",
+        },
+      };
+    },
+  );
+};

package/src/tools/skills/skill-get.ts

@@ -0,0 +1,75 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { getSkillById, getSkillByName } from "@/be/db";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerSkillGetTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "skill-get",
+    {
+      title: "Get Skill",
+      annotations: { destructiveHint: false },
+      description:
+        "Get full skill content by ID or name. Name resolution checks agent scope first, then swarm, then global.",
+      inputSchema: z.object({
+        skillId: z.string().optional().describe("Skill ID"),
+        name: z.string().optional().describe("Skill name (resolved with precedence)"),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+        skill: z.any().optional(),
+      }),
+    },
+    async (args, requestInfo, _meta) => {
+      if (!args.skillId && !args.name) {
+        return {
+          content: [{ type: "text", text: "Provide skillId or name." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "Provide skillId or name.",
+          },
+        };
+      }
+
+      let skill = null;
+
+      if (args.skillId) {
+        skill = getSkillById(args.skillId);
+      } else if (args.name && requestInfo.agentId) {
+        // Precedence: agent (personal) → swarm → global
+        skill =
+          getSkillByName(args.name, "agent", requestInfo.agentId) ||
+          getSkillByName(args.name, "swarm") ||
+          getSkillByName(args.name, "global");
+      } else if (args.name) {
+        skill = getSkillByName(args.name, "swarm") || getSkillByName(args.name, "global");
+      }
+
+      if (!skill) {
+        return {
+          content: [{ type: "text", text: "Skill not found." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "Skill not found.",
+          },
+        };
+      }
+
+      return {
+        content: [
+          { type: "text", text: `Skill "${skill.name}" (${skill.id}):\n\n${skill.content}` },
+        ],
+        structuredContent: {
+          yourAgentId: requestInfo.agentId,
+          success: true,
+          message: `Found skill "${skill.name}".`,
+          skill,
+        },
+      };
+    },
+  );
+};

package/src/tools/skills/skill-install-remote.ts

@@ -0,0 +1,152 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { createSkill, getAgentById } from "@/be/db";
+import { parseSkillContent } from "@/be/skill-parser";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerSkillInstallRemoteTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "skill-install-remote",
+    {
+      title: "Install Remote Skill",
+      annotations: { destructiveHint: false },
+      description:
+        "Fetch and install a remote skill from a GitHub repository. Fetches SKILL.md via GitHub raw content API.",
+      inputSchema: z.object({
+        sourceRepo: z.string().describe('GitHub repo (e.g. "vercel-labs/skills")'),
+        sourcePath: z.string().optional().describe('Path within repo (e.g. "skills/nextjs")'),
+        scope: z
+          .enum(["global", "swarm"])
+          .default("global")
+          .optional()
+          .describe("Scope for the installed skill"),
+        isComplex: z
+          .boolean()
+          .default(false)
+          .optional()
+          .describe("If true, registers for npx install (metadata only)"),
+      }),
+      outputSchema: z.object({
+        yourAgentId: z.string().uuid().optional(),
+        success: z.boolean(),
+        message: z.string(),
+        skill: z.any().optional(),
+      }),
+    },
+    async (args, requestInfo, _meta) => {
+      if (!requestInfo.agentId) {
+        return {
+          content: [{ type: "text", text: "Agent ID not found." }],
+          structuredContent: { success: false, message: "Agent ID not found." },
+        };
+      }
+
+      // Only leads can install global/swarm remote skills
+      const agent = getAgentById(requestInfo.agentId);
+      if (!agent?.isLead) {
+        return {
+          content: [{ type: "text", text: "Only lead agents can install remote skills." }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: "Only lead agents can install remote skills.",
+          },
+        };
+      }
+
+      try {
+        const branch = "main";
+        const filePath = args.sourcePath ? `${args.sourcePath}/SKILL.md` : "SKILL.md";
+        const rawUrl = `https://raw.githubusercontent.com/${args.sourceRepo}/${branch}/${filePath}`;
+
+        let content = "";
+        let sourceHash: string | null = null;
+
+        if (!args.isComplex) {
+          // Fetch SKILL.md content
+          const response = await fetch(rawUrl);
+          if (!response.ok) {
+            return {
+              content: [
+                {
+                  type: "text",
+                  text: `Failed to fetch SKILL.md from ${rawUrl}: ${response.status}`,
+                },
+              ],
+              structuredContent: {
+                yourAgentId: requestInfo.agentId,
+                success: false,
+                message: `Failed to fetch: HTTP ${response.status}`,
+              },
+            };
+          }
+          content = await response.text();
+          sourceHash = new Bun.CryptoHasher("sha256").update(content).digest("hex");
+        }
+
+        let name: string;
+        let description: string;
+        let parsedMeta: Partial<ReturnType<typeof parseSkillContent>> = {};
+
+        if (content) {
+          const parsed = parseSkillContent(content);
+          name = parsed.name;
+          description = parsed.description;
+          parsedMeta = parsed;
+        } else {
+          // Complex skill — use repo/path as name
+          name = args.sourcePath
+            ? args.sourcePath.split("/").pop() || args.sourceRepo
+            : args.sourceRepo.split("/").pop() || args.sourceRepo;
+          description = `Complex skill from ${args.sourceRepo}`;
+        }
+
+        const skill = createSkill({
+          name,
+          description,
+          content,
+          type: "remote",
+          scope: args.scope ?? "global",
+          sourceUrl: rawUrl,
+          sourceRepo: args.sourceRepo,
+          sourcePath: args.sourcePath,
+          sourceBranch: branch,
+          sourceHash: sourceHash ?? undefined,
+          isComplex: args.isComplex ?? false,
+          allowedTools: parsedMeta.allowedTools,
+          model: parsedMeta.model,
+          effort: parsedMeta.effort,
+          context: parsedMeta.context,
+          agent: parsedMeta.agent,
+          disableModelInvocation: parsedMeta.disableModelInvocation,
+          userInvocable: parsedMeta.userInvocable,
+        });
+
+        return {
+          content: [
+            {
+              type: "text",
+              text: `Installed remote skill "${skill.name}" from ${args.sourceRepo}`,
+            },
+          ],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: true,
+            message: `Installed remote skill "${skill.name}".`,
+            skill,
+          },
+        };
+      } catch (error) {
+        const message = error instanceof Error ? error.message : "Unknown error";
+        return {
+          content: [{ type: "text", text: `Failed: ${message}` }],
+          structuredContent: {
+            yourAgentId: requestInfo.agentId,
+            success: false,
+            message: `Failed: ${message}`,
+          },
+        };
+      }
+    },
+  );
+};