@desplega.ai/agent-swarm 1.57.4 → 1.58.0

package/src/tests/workflow-async-v2.test.ts

@@ -215,7 +215,7 @@ describe("Workflow Async v2 (Phase 4)", () => {
       });
 
       // Give the async handler time to process
-      await new Promise((resolve) => setTimeout(resolve, 200));
+      await new Promise((resolve) => setTimeout(resolve, 10));
 
       // Workflow should be completed now
       const updatedRun = getWorkflowRun(runId);
@@ -260,7 +260,7 @@ describe("Workflow Async v2 (Phase 4)", () => {
         workflowRunStepId: taskStep.id,
       });
 
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve) => setTimeout(resolve, 10));
 
       const updatedRun = getWorkflowRun(runId);
       expect(updatedRun!.status).toBe("failed");
@@ -291,7 +291,7 @@ describe("Workflow Async v2 (Phase 4)", () => {
         workflowRunStepId: taskStep.id,
       });
 
-      await new Promise((resolve) => setTimeout(resolve, 100));
+      await new Promise((resolve) => setTimeout(resolve, 10));
 
       const updatedRun = getWorkflowRun(runId);
       expect(updatedRun!.status).toBe("failed");
@@ -455,7 +455,7 @@ describe("Workflow Async v2 (Phase 4)", () => {
         workflowRunId: runId,
         workflowRunStepId: reviewSteps.find((s) => s.nodeId === "review-a")!.id,
       });
-      await new Promise((r) => setTimeout(r, 50));
+      await new Promise((r) => setTimeout(r, 10));
 
       // After A completes — merge should NOT have been created yet (B, C still pending)
       steps = getWorkflowRunStepsByRunId(runId);
@@ -472,7 +472,7 @@ describe("Workflow Async v2 (Phase 4)", () => {
         workflowRunId: runId,
         workflowRunStepId: reviewSteps.find((s) => s.nodeId === "review-b")!.id,
       });
-      await new Promise((r) => setTimeout(r, 50));
+      await new Promise((r) => setTimeout(r, 10));
 
       // After B completes — merge STILL should not exist (C still pending)
       steps = getWorkflowRunStepsByRunId(runId);
@@ -489,11 +489,11 @@ describe("Workflow Async v2 (Phase 4)", () => {
         workflowRunId: runId,
         workflowRunStepId: reviewSteps.find((s) => s.nodeId === "review-c")!.id,
       });
-      await new Promise((r) => setTimeout(r, 50));
+      await new Promise((r) => setTimeout(r, 10));
 
       // Now ALL 3 are done — merge should execute exactly ONCE
       // Allow extra time for serialized queue processing
-      await new Promise((r) => setTimeout(r, 100));
+      await new Promise((r) => setTimeout(r, 10));
 
       steps = getWorkflowRunStepsByRunId(runId);
       const mergeSteps = steps.filter((s) => s.nodeId === "merge");

package/src/tests/workflow-engine-v2.test.ts

@@ -386,8 +386,8 @@ describe("Workflow Engine v2 (Phase 3)", () => {
       const registry = createTestRegistry();
       const def: WorkflowDefinition = {
         nodes: [
-          // 60s delay should exceed the 30s default timeout
-          { id: "slow", type: "slow", config: { delayMs: 60_000 } },
+          // 2s delay should exceed the 500ms timeout
+          { id: "slow", type: "slow", config: { delayMs: 2_000, timeoutMs: 500 } },
         ],
       };
 
@@ -397,7 +397,7 @@ describe("Workflow Engine v2 (Phase 3)", () => {
       const run = getWorkflowRun(runId);
       expect(run!.status).toBe("failed");
       expect(run!.error).toContain("timed out");
-    }, 35_000); // Allow test up to 35s
+    }, 5_000); // Allow test up to 5s
   });
 
   // ─── Validation ───────────────────────────────────────────

package/src/tests/workflow-hitl-routing.test.ts

@@ -191,7 +191,7 @@ async function runHITLWorkflow(
   // Use a small delay to let the event handler finish
   const resumePromise = new Promise<void>((resolve) => {
     // Give the event handler time to run walkGraph
-    setTimeout(resolve, 200);
+    setTimeout(resolve, 10);
   });
 
   eventBus.emit("approval.resolved", {
@@ -360,7 +360,7 @@ describe("HITL port-based routing", () => {
     const requestId1 = hitlExecutor.lastRequestId!;
 
     // REJECT — should loop back to generate-question
-    const reject1Promise = new Promise<void>((resolve) => setTimeout(resolve, 200));
+    const reject1Promise = new Promise<void>((resolve) => setTimeout(resolve, 10));
     eventBus.emit("approval.resolved", {
       requestId: requestId1,
       status: "rejected",
@@ -392,7 +392,7 @@ describe("HITL port-based routing", () => {
     expect(requestId2).not.toBe(requestId1); // Different request
 
     // APPROVE — should go to success
-    const approve2Promise = new Promise<void>((resolve) => setTimeout(resolve, 200));
+    const approve2Promise = new Promise<void>((resolve) => setTimeout(resolve, 10));
     eventBus.emit("approval.resolved", {
       requestId: requestId2,
       status: "approved",
@@ -458,7 +458,7 @@ describe("HITL port-based routing", () => {
 
     // Simulate async task completion for generate-question (1st iteration)
     const genMeta1 = asyncTaskExecutor.lastMeta!;
-    const taskComplete1Promise = new Promise<void>((resolve) => setTimeout(resolve, 200));
+    const taskComplete1Promise = new Promise<void>((resolve) => setTimeout(resolve, 10));
     eventBus.emit("task.completed", {
       taskId: "fake-task-1",
       output: JSON.stringify({ question: "What is 2+2?" }),
@@ -478,7 +478,7 @@ describe("HITL port-based routing", () => {
     const requestId1 = hitlExecutor.lastRequestId!;
 
     // REJECT — should loop back to generate-question (async)
-    const reject1Promise = new Promise<void>((resolve) => setTimeout(resolve, 200));
+    const reject1Promise = new Promise<void>((resolve) => setTimeout(resolve, 10));
     eventBus.emit("approval.resolved", {
       requestId: requestId1,
       status: "rejected",
@@ -496,7 +496,7 @@ describe("HITL port-based routing", () => {
     expect(genMeta2.stepId).not.toBe(genMeta1.stepId); // Different step
 
     // Simulate async task completion for generate-question (2nd iteration)
-    const taskComplete2Promise = new Promise<void>((resolve) => setTimeout(resolve, 200));
+    const taskComplete2Promise = new Promise<void>((resolve) => setTimeout(resolve, 10));
     eventBus.emit("task.completed", {
       taskId: "fake-task-2",
       output: JSON.stringify({ question: "What is 3+3?" }),
@@ -523,7 +523,7 @@ describe("HITL port-based routing", () => {
     expect(requestId2).not.toBe(requestId1);
 
     // APPROVE — should go to success
-    const approve2Promise = new Promise<void>((resolve) => setTimeout(resolve, 200));
+    const approve2Promise = new Promise<void>((resolve) => setTimeout(resolve, 10));
     eventBus.emit("approval.resolved", {
       requestId: requestId2,
       status: "approved",

package/src/tests/workflow-http-v2.test.ts

@@ -652,7 +652,7 @@ describe("Workflow HTTP API v2", () => {
       const { runId } = (await triggerRes.json()) as { runId: string };
 
       // Wait for run to complete
-      await new Promise((r) => setTimeout(r, 100));
+      await new Promise((r) => setTimeout(r, 10));
 
       // Try to cancel — should fail
       const cancelRes = await fetch(`${baseUrl}/api/workflow-runs/${runId}/cancel`, {

package/src/tests/workflow-retry-v2.test.ts

@@ -251,7 +251,7 @@ describe("Workflow Retry v2 (Phase 4)", () => {
       expect(step.retryCount).toBe(1);
 
       // Wait for nextRetryAt to pass
-      await new Promise((resolve) => setTimeout(resolve, 50));
+      await new Promise((resolve) => setTimeout(resolve, 10));
 
       // Verify getRetryableSteps finds it
       const retryable = getRetryableSteps();
@@ -294,11 +294,11 @@ describe("Workflow Retry v2 (Phase 4)", () => {
 
       if (step.status === "failed" && step.nextRetryAt) {
         // Was given one retry chance — let it expire and start poller
-        await new Promise((resolve) => setTimeout(resolve, 50));
+        await new Promise((resolve) => setTimeout(resolve, 10));
 
         // Start poller with very short interval
-        startRetryPoller(registry, 50);
-        await new Promise((resolve) => setTimeout(resolve, 200));
+        startRetryPoller(registry, 10);
+        await new Promise((resolve) => setTimeout(resolve, 50));
         stopRetryPoller();
 
         // After retry, the second failure should be terminal (retryCount >= maxRetries)

package/src/tests/workflow-retry-validation.test.ts

@@ -192,10 +192,10 @@ describe("Retry Poller — Validation on Retry", () => {
     const validationCountAfterInitial = validateCallCount;
 
     // Wait for nextRetryAt to pass, then run the poller
-    await new Promise((resolve) => setTimeout(resolve, 50));
+    await new Promise((resolve) => setTimeout(resolve, 10));
 
-    startRetryPoller(registry, 50);
-    await new Promise((resolve) => setTimeout(resolve, 300));
+    startRetryPoller(registry, 10);
+    await new Promise((resolve) => setTimeout(resolve, 150));
     stopRetryPoller();
 
     // Validation should have been called again during the retry

package/src/tests/workflow-validation-port-routing.test.ts

@@ -0,0 +1,221 @@
+import { afterAll, beforeAll, describe, expect, test } from "bun:test";
+import { unlink } from "node:fs/promises";
+import { z } from "zod";
+import {
+  closeDb,
+  createWorkflow,
+  getWorkflowRun,
+  getWorkflowRunStepsByRunId,
+  initDb,
+} from "../be/db";
+import type { Workflow, WorkflowDefinition } from "../types";
+import { startWorkflowExecution } from "../workflows/engine";
+import { workflowEventBus } from "../workflows/event-bus";
+import {
+  BaseExecutor,
+  type ExecutorDependencies,
+  type ExecutorResult,
+} from "../workflows/executors/base";
+import { PropertyMatchExecutor } from "../workflows/executors/property-match";
+import { ExecutorRegistry } from "../workflows/executors/registry";
+import { interpolate } from "../workflows/template";
+
+const TEST_DB_PATH = "./test-workflow-validation-port-routing.sqlite";
+
+// ─── Test Executors ──────────────────────────────────────────
+
+/**
+ * Executor that returns a configurable object as output.
+ * Used to produce output that property-match can validate.
+ */
+class ObjectOutputExecutor extends BaseExecutor<
+  typeof ObjectOutputExecutor.schema,
+  typeof ObjectOutputExecutor.outSchema
+> {
+  static readonly schema = z.object({ approved: z.boolean() });
+  static readonly outSchema = z.object({ approved: z.boolean() });
+
+  readonly type = "object-output";
+  readonly mode = "instant" as const;
+  readonly configSchema = ObjectOutputExecutor.schema;
+  readonly outputSchema = ObjectOutputExecutor.outSchema;
+
+  protected async execute(
+    config: z.infer<typeof ObjectOutputExecutor.schema>,
+  ): Promise<ExecutorResult<z.infer<typeof ObjectOutputExecutor.outSchema>>> {
+    return { status: "success", output: { approved: config.approved } };
+  }
+}
+
+/**
+ * Terminal executor that just succeeds. Used for leaf nodes.
+ */
+class NoopExecutor extends BaseExecutor<typeof NoopExecutor.schema, typeof NoopExecutor.outSchema> {
+  static readonly schema = z.object({});
+  static readonly outSchema = z.object({ done: z.boolean() });
+
+  readonly type = "noop";
+  readonly mode = "instant" as const;
+  readonly configSchema = NoopExecutor.schema;
+  readonly outputSchema = NoopExecutor.outSchema;
+
+  protected async execute(): Promise<ExecutorResult<z.infer<typeof NoopExecutor.outSchema>>> {
+    return { status: "success", output: { done: true } };
+  }
+}
+
+// ─── Mock Dependencies ───────────────────────────────────────
+
+import * as db from "../be/db";
+
+const mockDeps: ExecutorDependencies = {
+  db: db as typeof import("../be/db"),
+  eventBus: workflowEventBus,
+  interpolate: (template, ctx) => interpolate(template, ctx).result,
+};
+
+function createTestRegistry(): ExecutorRegistry {
+  const registry = new ExecutorRegistry();
+  registry.register(new ObjectOutputExecutor(mockDeps));
+  registry.register(new NoopExecutor(mockDeps));
+  registry.register(new PropertyMatchExecutor(mockDeps));
+  return registry;
+}
+
+let workflowCounter = 0;
+
+function makeWorkflow(def: WorkflowDefinition): Workflow {
+  workflowCounter++;
+  return createWorkflow({
+    name: `test-val-port-routing-${workflowCounter}-${Date.now()}`,
+    definition: def,
+  });
+}
+
+// ─── Setup / Teardown ────────────────────────────────────────
+
+let registry: ExecutorRegistry;
+
+beforeAll(async () => {
+  try {
+    await unlink(TEST_DB_PATH);
+  } catch {}
+  initDb(TEST_DB_PATH);
+  registry = createTestRegistry();
+});
+
+afterAll(async () => {
+  closeDb();
+  for (const suffix of ["", "-wal", "-shm"]) {
+    try {
+      await unlink(`${TEST_DB_PATH}${suffix}`);
+    } catch {}
+  }
+});
+
+// ─── Tests ───────────────────────────────────────────────────
+
+describe("Validation Port Routing", () => {
+  /**
+   * Regression test for: when a node has record-based `next` (pass/fail ports)
+   * and validation with `mustPass: false`, only the matching port should be activated.
+   * Previously, all ports were activated because `result.nextPort` was never set.
+   */
+
+  function makePortRoutingWorkflow(approved: boolean): WorkflowDefinition {
+    return {
+      nodes: [
+        {
+          id: "check",
+          type: "object-output",
+          config: { approved },
+          next: { pass: "on-pass", fail: "on-fail" },
+          validation: {
+            executor: "property-match",
+            config: {
+              conditions: [{ field: "check.approved", op: "eq", value: true }],
+            },
+            mustPass: false,
+          },
+        },
+        {
+          id: "on-pass",
+          type: "noop",
+          config: {},
+        },
+        {
+          id: "on-fail",
+          type: "noop",
+          config: {},
+        },
+      ],
+    };
+  }
+
+  test("validation passes → only 'pass' port successor is created", async () => {
+    const workflow = makeWorkflow(makePortRoutingWorkflow(true));
+    const runId = await startWorkflowExecution(workflow, {}, registry);
+
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const nodeIds = steps.map((s) => s.nodeId);
+
+    // "check" should be completed, "on-pass" should exist, "on-fail" should NOT
+    expect(nodeIds).toContain("check");
+    expect(nodeIds).toContain("on-pass");
+    expect(nodeIds).not.toContain("on-fail");
+
+    const run = getWorkflowRun(runId);
+    expect(run!.status).toBe("completed");
+  });
+
+  test("validation fails (mustPass: false) → only 'fail' port successor is created", async () => {
+    const workflow = makeWorkflow(makePortRoutingWorkflow(false));
+    const runId = await startWorkflowExecution(workflow, {}, registry);
+
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const nodeIds = steps.map((s) => s.nodeId);
+
+    // "check" should be completed, "on-fail" should exist, "on-pass" should NOT
+    expect(nodeIds).toContain("check");
+    expect(nodeIds).toContain("on-fail");
+    expect(nodeIds).not.toContain("on-pass");
+
+    const run = getWorkflowRun(runId);
+    expect(run!.status).toBe("completed");
+  });
+
+  test("string-based next is unaffected by validation port routing", async () => {
+    const workflow = makeWorkflow({
+      nodes: [
+        {
+          id: "check",
+          type: "object-output",
+          config: { approved: false },
+          next: "successor",
+          validation: {
+            executor: "property-match",
+            config: {
+              conditions: [{ field: "check.approved", op: "eq", value: true }],
+            },
+            mustPass: false,
+          },
+        },
+        {
+          id: "successor",
+          type: "noop",
+          config: {},
+        },
+      ],
+    });
+
+    const runId = await startWorkflowExecution(workflow, {}, registry);
+    const steps = getWorkflowRunStepsByRunId(runId);
+    const nodeIds = steps.map((s) => s.nodeId);
+
+    expect(nodeIds).toContain("check");
+    expect(nodeIds).toContain("successor");
+
+    const run = getWorkflowRun(runId);
+    expect(run!.status).toBe("completed");
+  });
+});

package/src/tools/get-task-details.ts

@@ -1,6 +1,6 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import * as z from "zod";
-import { getLogsByTaskIdChronological, getTaskById } from "@/be/db";
+import { getLogsByTaskIdChronological, getTaskById, getUserById } from "@/be/db";
 import { createToolRegistrar } from "@/tools/utils";
 import { AgentLogSchema, AgentTaskSchema } from "@/types";
 
@@ -21,6 +21,10 @@ export const registerGetTaskDetailsTool = (server: McpServer) => {
         success: z.boolean(),
         message: z.string(),
         task: AgentTaskSchema.optional(),
+        requestedBy: z
+          .object({ name: z.string(), email: z.string().optional() })
+          .optional()
+          .describe("Resolved user who requested this task"),
         logs: z.array(AgentLogSchema).optional(),
       }),
     },
@@ -40,6 +44,14 @@ export const registerGetTaskDetailsTool = (server: McpServer) => {
 
       const logs = getLogsByTaskIdChronological(taskId);
 
+      // Resolve requesting user details if available
+      const requestedByUser = task.requestedByUserId
+        ? getUserById(task.requestedByUserId)
+        : undefined;
+      const requestedBy = requestedByUser
+        ? { name: requestedByUser.name, email: requestedByUser.email }
+        : undefined;
+
       return {
         content: [{ type: "text", text: `Task "${taskId}" details retrieved.` }],
         structuredContent: {
@@ -47,6 +59,7 @@ export const registerGetTaskDetailsTool = (server: McpServer) => {
           success: true,
           message: `Task "${taskId}" details retrieved.`,
           task,
+          requestedBy,
           logs,
         },
       };

package/src/tools/manage-user.ts

@@ -0,0 +1,172 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import {
+  createUser,
+  deleteUser,
+  getAgentById,
+  getAllUsers,
+  getUserById,
+  updateUser,
+} from "@/be/db";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerManageUserTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "manage-user",
+    {
+      title: "Manage user profiles",
+      description: "Create, update, delete, or list user profiles in the user registry. Lead-only.",
+      annotations: { readOnlyHint: false },
+      inputSchema: z.object({
+        action: z.enum(["create", "update", "delete", "list", "get"]).describe("Action to perform"),
+        userId: z.string().optional().describe("User ID (required for update/delete/get)"),
+        name: z.string().optional().describe("Display name (required for create)"),
+        email: z.string().optional().describe("Primary email address"),
+        role: z.string().optional().describe('Role (e.g., "founder", "engineer")'),
+        notes: z.string().optional().describe("Free-form notes"),
+        slackUserId: z.string().optional().describe("Slack user ID"),
+        linearUserId: z.string().optional().describe("Linear user UUID"),
+        githubUsername: z.string().optional().describe("GitHub username"),
+        gitlabUsername: z.string().optional().describe("GitLab username"),
+        emailAliases: z.array(z.string()).optional().describe("Additional email addresses"),
+        preferredChannel: z.string().optional().describe("Preferred contact channel"),
+        timezone: z.string().optional().describe("Timezone (e.g., America/New_York)"),
+      }),
+    },
+    async (input, requestInfo) => {
+      const callerAgent = requestInfo.agentId ? getAgentById(requestInfo.agentId) : null;
+      if (!callerAgent?.isLead) {
+        return {
+          content: [
+            { type: "text" as const, text: "Only the lead agent can manage user profiles." },
+          ],
+        };
+      }
+
+      switch (input.action) {
+        case "list": {
+          const users = getAllUsers();
+          return {
+            content: [{ type: "text" as const, text: JSON.stringify(users, null, 2) }],
+          };
+        }
+
+        case "get": {
+          if (!input.userId) {
+            return {
+              content: [{ type: "text" as const, text: "userId is required for get action." }],
+            };
+          }
+          const user = getUserById(input.userId);
+          if (!user) {
+            return {
+              content: [{ type: "text" as const, text: `User ${input.userId} not found.` }],
+            };
+          }
+          return {
+            content: [{ type: "text" as const, text: JSON.stringify(user, null, 2) }],
+          };
+        }
+
+        case "create": {
+          if (!input.name) {
+            return {
+              content: [{ type: "text" as const, text: "name is required for create action." }],
+            };
+          }
+          try {
+            const user = createUser({
+              name: input.name,
+              email: input.email,
+              role: input.role,
+              notes: input.notes,
+              slackUserId: input.slackUserId,
+              linearUserId: input.linearUserId,
+              githubUsername: input.githubUsername,
+              gitlabUsername: input.gitlabUsername,
+              emailAliases: input.emailAliases,
+              preferredChannel: input.preferredChannel,
+              timezone: input.timezone,
+            });
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: `User created: ${JSON.stringify(user, null, 2)}`,
+                },
+              ],
+            };
+          } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+              content: [{ type: "text" as const, text: `Failed to create user: ${message}` }],
+            };
+          }
+        }
+
+        case "update": {
+          if (!input.userId) {
+            return {
+              content: [{ type: "text" as const, text: "userId is required for update action." }],
+            };
+          }
+          try {
+            const user = updateUser(input.userId, {
+              name: input.name,
+              email: input.email,
+              role: input.role,
+              notes: input.notes,
+              slackUserId: input.slackUserId,
+              linearUserId: input.linearUserId,
+              githubUsername: input.githubUsername,
+              gitlabUsername: input.gitlabUsername,
+              emailAliases: input.emailAliases,
+              preferredChannel: input.preferredChannel,
+              timezone: input.timezone,
+            });
+            if (!user) {
+              return {
+                content: [{ type: "text" as const, text: `User ${input.userId} not found.` }],
+              };
+            }
+            return {
+              content: [
+                {
+                  type: "text" as const,
+                  text: `User updated: ${JSON.stringify(user, null, 2)}`,
+                },
+              ],
+            };
+          } catch (err: unknown) {
+            const message = err instanceof Error ? err.message : String(err);
+            return {
+              content: [{ type: "text" as const, text: `Failed to update user: ${message}` }],
+            };
+          }
+        }
+
+        case "delete": {
+          if (!input.userId) {
+            return {
+              content: [{ type: "text" as const, text: "userId is required for delete action." }],
+            };
+          }
+          const deleted = deleteUser(input.userId);
+          return {
+            content: [
+              {
+                type: "text" as const,
+                text: deleted ? `User ${input.userId} deleted.` : `User ${input.userId} not found.`,
+              },
+            ],
+          };
+        }
+
+        default:
+          return {
+            content: [{ type: "text" as const, text: `Unknown action: ${input.action}` }],
+          };
+      }
+    },
+  );
+};

package/src/tools/resolve-user.ts

@@ -0,0 +1,55 @@
+import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import * as z from "zod";
+import { resolveUser } from "@/be/db";
+import { createToolRegistrar } from "@/tools/utils";
+
+export const registerResolveUserTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "resolve-user",
+    {
+      title: "Resolve user identity",
+      description:
+        "Look up a canonical user profile by any platform-specific identifier (Slack ID, Linear ID, GitHub username, email, or name). Returns the full user profile or null.",
+      annotations: { readOnlyHint: true },
+      inputSchema: z.object({
+        slackUserId: z.string().optional().describe("Slack user ID (e.g., U08NR6QD6CS)"),
+        linearUserId: z.string().optional().describe("Linear user UUID"),
+        githubUsername: z.string().optional().describe("GitHub username"),
+        gitlabUsername: z.string().optional().describe("GitLab username"),
+        email: z.string().optional().describe("Email address"),
+        name: z.string().optional().describe("Name (fuzzy substring match, lowest priority)"),
+      }),
+    },
+    async ({ slackUserId, linearUserId, githubUsername, gitlabUsername, email, name }) => {
+      if (!slackUserId && !linearUserId && !githubUsername && !gitlabUsername && !email && !name) {
+        return {
+          content: [
+            {
+              type: "text" as const,
+              text: "At least one search parameter is required.",
+            },
+          ],
+        };
+      }
+
+      const user = resolveUser({
+        slackUserId,
+        linearUserId,
+        githubUsername,
+        gitlabUsername,
+        email,
+        name,
+      });
+
+      if (!user) {
+        return {
+          content: [{ type: "text" as const, text: "No user found matching the given criteria." }],
+        };
+      }
+
+      return {
+        content: [{ type: "text" as const, text: JSON.stringify(user, null, 2) }],
+      };
+    },
+  );
+};