@desplega.ai/agent-swarm 1.52.0 → 1.52.1

package/src/tests/tool-call-progress.test.ts

@@ -0,0 +1,207 @@
+import { describe, expect, test } from "bun:test";
+import { humanizeToolName, toolCallToProgress } from "../commands/runner";
+
+describe("toolCallToProgress", () => {
+  // --- Core Claude Code tools ---
+
+  test("Read tool includes emoji and short path", () => {
+    const result = toolCallToProgress("Read", {
+      file_path: "/Users/taras/Documents/code/agent-swarm/src/commands/runner.ts",
+    });
+    expect(result).toBe("📖 Reading commands/runner.ts");
+  });
+
+  test("Edit tool includes emoji and short path", () => {
+    const result = toolCallToProgress("Edit", {
+      file_path: "/Users/taras/code/src/index.ts",
+    });
+    expect(result).toBe("✏️ Editing src/index.ts");
+  });
+
+  test("MultiEdit uses same format as Edit", () => {
+    const result = toolCallToProgress("MultiEdit", {
+      file_path: "/a/b/c/d.ts",
+    });
+    expect(result).toBe("✏️ Editing c/d.ts");
+  });
+
+  test("Write tool includes emoji and short path", () => {
+    const result = toolCallToProgress("Write", {
+      file_path: "/Users/taras/code/new-file.ts",
+    });
+    expect(result).toBe("📝 Writing code/new-file.ts");
+  });
+
+  test("Bash tool uses description when available", () => {
+    const result = toolCallToProgress("Bash", {
+      description: "Running tests",
+      command: "bun test",
+    });
+    expect(result).toBe("⚡ Running tests");
+  });
+
+  test("Bash tool falls back when no description", () => {
+    const result = toolCallToProgress("Bash", { command: "ls -la" });
+    expect(result).toBe("⚡ Running shell command");
+  });
+
+  test("Grep tool shows search pattern", () => {
+    const result = toolCallToProgress("Grep", { pattern: "TODO" });
+    expect(result).toBe('🔍 Searching for "TODO"');
+  });
+
+  test("Glob tool shows file pattern", () => {
+    const result = toolCallToProgress("Glob", { pattern: "**/*.test.ts" });
+    expect(result).toBe("📁 Finding files matching **/*.test.ts");
+  });
+
+  test("Agent tool uses description when available", () => {
+    const result = toolCallToProgress("Agent", {
+      description: "Exploring codebase structure",
+    });
+    expect(result).toBe("🤖 Exploring codebase structure");
+  });
+
+  test("Agent tool falls back when no description", () => {
+    const result = toolCallToProgress("Agent", {});
+    expect(result).toBe("🤖 Delegating sub-task");
+  });
+
+  test("Task tool uses description", () => {
+    const result = toolCallToProgress("Task", {
+      description: "Running lint checks",
+    });
+    expect(result).toBe("🤖 Running lint checks");
+  });
+
+  test("Skill tool shows skill name", () => {
+    const result = toolCallToProgress("Skill", { skill: "commit" });
+    expect(result).toBe("⚙️ Running /commit");
+  });
+
+  // --- Skip list ---
+
+  test("ToolSearch is skipped (returns null)", () => {
+    expect(toolCallToProgress("ToolSearch", {})).toBeNull();
+  });
+
+  test("TodoRead is skipped", () => {
+    expect(toolCallToProgress("TodoRead", {})).toBeNull();
+  });
+
+  test("TodoWrite is skipped", () => {
+    expect(toolCallToProgress("TodoWrite", {})).toBeNull();
+  });
+
+  // --- Unknown default tools ---
+
+  test("unknown tool gets fallback with emoji", () => {
+    const result = toolCallToProgress("SomeNewTool", {});
+    expect(result).toBe("🔧 SomeNewTool");
+  });
+
+  // --- Agent-swarm MCP tools (with pretty labels) ---
+
+  test("agent-swarm:get-task-details has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__get-task-details", {});
+    expect(result).toBe("📋 Reviewing task details");
+  });
+
+  test("agent-swarm:send-task has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__send-task", {});
+    expect(result).toBe("📤 Delegating task");
+  });
+
+  test("agent-swarm:post-message has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__post-message", {});
+    expect(result).toBe("💬 Sending message");
+  });
+
+  test("agent-swarm:store-progress is skipped (meta/noise)", () => {
+    expect(toolCallToProgress("mcp__agent-swarm__store-progress", {})).toBeNull();
+  });
+
+  test("agent-swarm:poll-task has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__poll-task", {});
+    expect(result).toBe("📡 Polling for tasks");
+  });
+
+  test("agent-swarm:request-human-input has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__request-human-input", {});
+    expect(result).toBe("🙋 Requesting human input");
+  });
+
+  test("agent-swarm:memory-search has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__memory-search", {});
+    expect(result).toBe("🧠 Searching memory");
+  });
+
+  test("agent-swarm:tracker-status has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__tracker-status", {});
+    expect(result).toBe("📊 Checking tracker status");
+  });
+
+  test("agent-swarm:trigger-workflow has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__trigger-workflow", {});
+    expect(result).toBe("⚙️ Triggering workflow");
+  });
+
+  test("agent-swarm:slack-post has pretty label", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__slack-post", {});
+    expect(result).toBe("💬 Posting to Slack");
+  });
+
+  // --- Agent-swarm MCP tool NOT in lookup (humanized fallback) ---
+
+  test("unknown agent-swarm tool gets humanized fallback", () => {
+    const result = toolCallToProgress("mcp__agent-swarm__some-new-tool", {});
+    expect(result).toBe("🔌 Some new tool");
+  });
+
+  // --- Other MCP servers ---
+
+  test("other MCP server tool gets server prefix + humanized name", () => {
+    const result = toolCallToProgress("mcp__linear__list-issues", {});
+    expect(result).toBe("🔌 linear: List issues");
+  });
+
+  test("other MCP server with simple tool name", () => {
+    const result = toolCallToProgress("mcp__github__search", {});
+    expect(result).toBe("🔌 github: Search");
+  });
+
+  test("MCP tool with double underscores in tool name", () => {
+    const result = toolCallToProgress("mcp__context7__query-docs", {});
+    expect(result).toBe("🔌 context7: Query docs");
+  });
+
+  // --- Short path helper (tested implicitly) ---
+
+  test("Read with short path (<=2 segments) keeps full path", () => {
+    const result = toolCallToProgress("Read", { file_path: "file.ts" });
+    expect(result).toBe("📖 Reading file.ts");
+  });
+
+  test("Read with missing file_path shows empty", () => {
+    const result = toolCallToProgress("Read", {});
+    expect(result).toBe("📖 Reading ");
+  });
+});
+
+describe("humanizeToolName", () => {
+  test("converts kebab-case to sentence case", () => {
+    expect(humanizeToolName("get-task-details")).toBe("Get task details");
+  });
+
+  test("single word gets capitalized", () => {
+    expect(humanizeToolName("search")).toBe("Search");
+  });
+
+  test("multi-word kebab-case", () => {
+    expect(humanizeToolName("list-all-workflow-runs")).toBe("List all workflow runs");
+  });
+
+  test("empty string returns empty", () => {
+    expect(humanizeToolName("")).toBe("");
+  });
+});

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/tools/request-human-input.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { createApprovalRequest } from "@/be/db";
+import { createApprovalRequest, getAgentCurrentTask } from "@/be/db";
 import { createToolRegistrar } from "@/tools/utils";
 
 const QuestionSchema = z.object({
@@ -73,18 +73,29 @@ export const registerRequestHumanInputTool = (server: McpServer) => {
         };
       }
 
+      // 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: requestInfo.sourceTaskId ?? undefined,
+        sourceTaskId: sourceTaskId ?? undefined,
         timeoutSeconds,
       });
 
       const appUrl = process.env.APP_URL || "http://localhost:5274";
-      const url = `${appUrl}/requests/${request.id}`;
+      const url = `${appUrl}/approval-requests/${request.id}`;
 
       return {
         content: [

package/src/tools/store-progress.ts

@@ -1,3 +1,4 @@
+import { ensure } from "@desplega.ai/business-use";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
 import {
@@ -161,6 +162,21 @@ export const registerStoreProgressTool = (server: McpServer) => {
           const result = completeTask(taskId, output);
           if (result) {
             updatedTask = result;
+
+            ensure({
+              id: "completed",
+              flow: "task",
+              runId: taskId,
+              depIds: ["started"],
+              data: {
+                taskId,
+                agentId: existingTask.agentId,
+                previousStatus: existingTask.status,
+                hasOutput: !!output,
+              },
+              validator: (data) => data.previousStatus === "in_progress",
+            });
+
             if (existingTask.agentId) {
               // Derive status from capacity instead of always setting idle
               updateAgentStatusFromCapacity(existingTask.agentId);
@@ -170,6 +186,21 @@ export const registerStoreProgressTool = (server: McpServer) => {
           const result = failTask(taskId, failureReason ?? "Unknown failure");
           if (result) {
             updatedTask = result;
+
+            ensure({
+              id: "failed",
+              flow: "task",
+              runId: taskId,
+              depIds: ["started"],
+              data: {
+                taskId,
+                agentId: existingTask.agentId,
+                previousStatus: existingTask.status,
+                failureReason: failureReason ?? "Unknown failure",
+              },
+              validator: (data) => data.previousStatus === "in_progress",
+            });
+
             if (existingTask.agentId) {
               // Derive status from capacity instead of always setting idle
               updateAgentStatusFromCapacity(existingTask.agentId);

package/src/tools/templates.ts

@@ -32,6 +32,34 @@ Use \`get-task-details\` with taskId "{{task_id}}" for full details.`,
   category: "task_lifecycle",
 });
 
+// ============================================================================
+// HITL follow-up (created when a standalone approval request is resolved)
+// ============================================================================
+
+registerTemplate({
+  eventType: "hitl.follow_up",
+  header: "",
+  defaultBody: `Human responded to your approval request ({{request_id}}).
+
+Title: {{title}}
+Status: {{status}}
+
+Questions and responses:
+{{responses}}
+
+Continue your work based on the human's input.`,
+  variables: [
+    { name: "request_id", description: "The approval request ID" },
+    { name: "title", description: "Title of the approval request" },
+    { name: "status", description: "Resolution status: approved or rejected" },
+    {
+      name: "responses",
+      description: "Formatted questions and human responses",
+    },
+  ],
+  category: "task_lifecycle",
+});
+
 registerTemplate({
   eventType: "task.worker.failed",
   header: "",

package/src/tools/utils.ts

@@ -101,17 +101,19 @@ export const createToolRegistrar = (server: McpServer) => {
     config: ToolConfig<InputArgs, OutputArgs>,
     cb: ToolCallbackWithInfo<InputArgs>,
   ) => {
-    return server.registerTool(name, config, ((args: InferInput<InputArgs>, meta: Meta) => {
-      const requestInfo = getRequestInfo(meta);
-
-      // Handle zero-argument case
-      if (config.inputSchema === undefined) {
+    // When inputSchema is undefined, the MCP SDK calls handler(extra) with a single arg.
+    // When inputSchema is defined, it calls handler(args, extra) with two args.
+    if (config.inputSchema === undefined) {
+      return server.registerTool(name, config, ((meta: Meta) => {
+        const requestInfo = getRequestInfo(meta);
         return (
           cb as (requestInfo: RequestInfo, meta: Meta) => CallToolResult | Promise<CallToolResult>
         )(requestInfo, meta);
-      }
+      }) as Parameters<typeof server.registerTool>[2]);
+    }
 
-      // Handle with-arguments case
+    return server.registerTool(name, config, ((args: InferInput<InputArgs>, meta: Meta) => {
+      const requestInfo = getRequestInfo(meta);
       return (
         cb as (
           args: InferInput<InputArgs>,

package/src/workflows/executors/human-in-the-loop.ts

@@ -146,10 +146,17 @@ export class HumanInTheLoopExecutor extends BaseExecutor<
       workflowRunId: meta.runId,
       workflowRunStepId: meta.stepId,
       timeoutSeconds: config.timeout?.seconds,
-      notificationChannels: config.notifications, // TODO: Notifications are stored but not dispatched yet (Phase 2)
+      notificationChannels: config.notifications,
     });
 
-    // 3. Return async result — engine will pause the workflow
+    // 3. Dispatch notifications (fire-and-forget — failures must not block the workflow)
+    if (config.notifications?.length) {
+      this.dispatchNotifications(requestId, config, db).catch((err) => {
+        console.error("[HITL] Unexpected error dispatching notifications:", err);
+      });
+    }
+
+    // 4. Return async result — engine will pause the workflow
     return {
       status: "success",
       async: true,
@@ -157,4 +164,110 @@ export class HumanInTheLoopExecutor extends BaseExecutor<
       correlationId: requestId,
     } as unknown as ExecutorResult<HITLOutput>;
   }
+
+  /** Dispatch notifications for each configured channel. Updates DB with messageTs on success. */
+  private async dispatchNotifications(
+    requestId: string,
+    config: z.infer<typeof HITLConfigSchema>,
+    db: typeof import("../../be/db"),
+  ): Promise<void> {
+    if (!config.notifications?.length) return;
+
+    const approvalUrl = `https://app.agent-swarm.dev/approval-requests/${requestId}`;
+    const updatedChannels = [...config.notifications] as Array<
+      z.infer<typeof NotificationConfigSchema> & { messageTs?: string }
+    >;
+    let updated = false;
+
+    for (let i = 0; i < config.notifications.length; i++) {
+      const notification = config.notifications[i]!;
+
+      if (notification.channel === "email") {
+        console.warn(
+          `[HITL] Email notifications not yet supported (target: ${notification.target})`,
+        );
+        continue;
+      }
+
+      if (notification.channel === "slack") {
+        try {
+          const { getSlackApp } = await import("../../slack/app");
+          const slackApp = getSlackApp();
+          if (!slackApp) {
+            console.warn("[HITL] Slack not initialized — cannot send notification");
+            continue;
+          }
+
+          const questionsSummary = config.questions.map((q) => `• ${q.label}`).join("\n");
+
+          const timeoutText = config.timeout
+            ? `\n⏱ _Timeout: ${formatTimeout(config.timeout.seconds)} — auto-rejects if not responded_`
+            : "";
+
+          const blocks = [
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: `🔔 *Approval Required: ${config.title}*`,
+              },
+            },
+            {
+              type: "section",
+              text: {
+                type: "mrkdwn",
+                text: `*Questions:*\n${questionsSummary}${timeoutText}`,
+              },
+            },
+            {
+              type: "actions",
+              elements: [
+                {
+                  type: "button",
+                  text: { type: "plain_text", text: "Review & Respond" },
+                  url: approvalUrl,
+                  style: "primary",
+                },
+              ],
+            },
+          ];
+
+          const result = await slackApp.client.chat.postMessage({
+            channel: notification.target,
+            text: `Approval Required: ${config.title} — ${approvalUrl}`,
+            // biome-ignore lint/suspicious/noExplicitAny: Block Kit objects
+            blocks: blocks as any,
+          });
+
+          if (result.ts) {
+            updatedChannels[i] = { ...notification, messageTs: result.ts };
+            updated = true;
+          }
+
+          console.log(
+            `[HITL] Slack notification sent to ${notification.target} for request ${requestId}`,
+          );
+        } catch (err) {
+          console.error(`[HITL] Failed to send Slack notification to ${notification.target}:`, err);
+        }
+      }
+    }
+
+    // Persist messageTs values back to DB
+    if (updated) {
+      try {
+        db.updateApprovalRequestNotifications(requestId, updatedChannels);
+      } catch (err) {
+        console.error("[HITL] Failed to update notification channels in DB:", err);
+      }
+    }
+  }
+}
+
+function formatTimeout(seconds: number): string {
+  if (seconds < 60) return `${seconds}s`;
+  if (seconds < 3600) return `${Math.round(seconds / 60)}m`;
+  const hours = Math.floor(seconds / 3600);
+  const mins = Math.round((seconds % 3600) / 60);
+  return mins > 0 ? `${hours}h ${mins}m` : `${hours}h`;
 }