@desplega.ai/agent-swarm 1.83.1 → 1.83.2

package/src/tools/cancel-task.ts

@@ -1,4 +1,5 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import * as z from "zod";
 import {
   cancelTask,
@@ -7,107 +8,160 @@ import {
   getTaskById,
   updateAgentStatusFromCapacity,
 } from "@/be/db";
+import { assertOwnsTask, ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import { createToolRegistrar } from "@/tools/utils";
 import type { AgentTask } from "@/types";
 import { AgentTaskSchema } from "@/types";
 
-export const registerCancelTaskTool = (server: McpServer) => {
-  createToolRegistrar(server)(
-    "cancel-task",
-    {
-      title: "Cancel Task",
-      description:
-        "Cancel a task that is pending or in progress. Only the lead or task creator can cancel tasks. The worker will be notified via hooks.",
-      annotations: { destructiveHint: true },
+export const cancelTaskInputSchema = z.object({
+  taskId: z.uuid().describe("The ID of the task to cancel."),
+  reason: z.string().optional().describe("Reason for cancellation."),
+});
 
-      inputSchema: z.object({
-        taskId: z.uuid().describe("The ID of the task to cancel."),
-        reason: z.string().optional().describe("Reason for cancellation."),
-      }),
-      outputSchema: z.object({
-        yourAgentId: z.string().uuid().optional(),
-        success: z.boolean(),
-        message: z.string(),
-        task: AgentTaskSchema.optional(),
-      }),
-    },
-    async (input, requestInfo, _meta) => {
-      const { taskId, reason } = input;
+export const cancelTaskOutputSchema = z.object({
+  yourAgentId: z.string().uuid().optional(),
+  success: z.boolean(),
+  message: z.string(),
+  task: AgentTaskSchema.optional(),
+});
+
+type CancelTaskArgs = z.infer<typeof cancelTaskInputSchema>;
+
+export async function cancelTaskHandler(
+  ctx: ToolCtx,
+  { taskId, reason }: CancelTaskArgs,
+): Promise<CallToolResult> {
+  if (ctx.kind === "owner" && !ctx.agentId) {
+    return {
+      content: [{ type: "text", text: 'Agent ID not found. Set the "X-Agent-ID" header.' }],
+      structuredContent: {
+        success: false,
+        message: 'Agent ID not found. Set the "X-Agent-ID" header.',
+      },
+    };
+  }
+
+  const agentId = ctx.kind === "owner" ? ctx.agentId : undefined;
 
-      if (!requestInfo.agentId) {
+  const txn = getDb().transaction(() => {
+    if (ctx.kind === "owner") {
+      const ownerAgentId = ctx.agentId;
+      if (!ownerAgentId) {
         return {
-          content: [{ type: "text", text: 'Agent ID not found. Set the "X-Agent-ID" header.' }],
-          structuredContent: {
-            success: false,
-            message: 'Agent ID not found. Set the "X-Agent-ID" header.',
-          },
+          success: false,
+          message: 'Agent ID not found. Set the "X-Agent-ID" header.',
         };
       }
+      const callerAgent = getAgentById(ownerAgentId);
 
-      const agentId = requestInfo.agentId;
-
-      const txn = getDb().transaction(() => {
-        const callerAgent = getAgentById(agentId);
-
-        if (!callerAgent) {
-          return {
-            success: false,
-            message: "Caller agent not found.",
-          };
-        }
-
-        const existingTask = getTaskById(taskId);
-
-        if (!existingTask) {
-          return {
-            success: false,
-            message: `Task "${taskId}" not found.`,
-          };
-        }
-
-        // Verify the requester has permission (lead or task creator)
-        const canCancel = callerAgent.isLead || existingTask.creatorAgentId === agentId;
-        if (!canCancel) {
-          return {
-            success: false,
-            message: "Only the lead or task creator can cancel tasks.",
-          };
-        }
-
-        const cancelled = cancelTask(taskId, reason);
-
-        if (!cancelled) {
-          return {
-            success: false,
-            message: `Cannot cancel task in status "${existingTask.status}". Only pending/in_progress tasks can be cancelled.`,
-          };
-        }
-
-        // Update agent status based on capacity
-        if (cancelled.agentId) {
-          updateAgentStatusFromCapacity(cancelled.agentId);
-        }
+      if (!callerAgent) {
+        return {
+          success: false,
+          message: "Caller agent not found.",
+        };
+      }
 
+      const existingTask = getTaskById(taskId);
+
+      if (!existingTask) {
         return {
-          success: true,
-          message: `Task "${taskId}" has been cancelled.`,
-          task: cancelled,
+          success: false,
+          message: `Task "${taskId}" not found.`,
         };
-      });
+      }
 
-      const result = txn() as {
-        success: boolean;
-        message: string;
-        task?: AgentTask;
+      // Verify the requester has permission (lead or task creator)
+      const canCancel = callerAgent.isLead || existingTask.creatorAgentId === ownerAgentId;
+      if (!canCancel) {
+        return {
+          success: false,
+          message: "Only the lead or task creator can cancel tasks.",
+        };
+      }
+
+      const cancelled = cancelTask(taskId, reason);
+
+      if (!cancelled) {
+        return {
+          success: false,
+          message: `Cannot cancel task in status "${existingTask.status}". Only pending/in_progress tasks can be cancelled.`,
+        };
+      }
+
+      // Update agent status based on capacity
+      if (cancelled.agentId) {
+        updateAgentStatusFromCapacity(cancelled.agentId);
+      }
+
+      return {
+        success: true,
+        message: `Task "${taskId}" has been cancelled.`,
+        task: cancelled,
+      };
+    }
+
+    const existingTask = getTaskById(taskId);
+
+    if (!existingTask) {
+      return {
+        success: false,
+        message: `Task "${taskId}" not found.`,
       };
+    }
 
+    const ownershipError = assertOwnsTask(ctx, existingTask);
+    if (ownershipError) return ownershipError;
+
+    const cancelled = cancelTask(taskId, reason);
+
+    if (!cancelled) {
       return {
-        content: [{ type: "text", text: result.message }],
-        structuredContent: {
-          yourAgentId: agentId,
-          ...result,
-        },
+        success: false,
+        message: `Cannot cancel task in status "${existingTask.status}". Only pending/in_progress tasks can be cancelled.`,
       };
+    }
+
+    if (cancelled.agentId) {
+      updateAgentStatusFromCapacity(cancelled.agentId);
+    }
+
+    return {
+      success: true,
+      message: `Task "${taskId}" has been cancelled.`,
+      task: cancelled,
+    };
+  });
+
+  const result = txn() as
+    | {
+        success: boolean;
+        message: string;
+        task?: AgentTask;
+      }
+    | CallToolResult;
+
+  if ("content" in result) return result;
+
+  return {
+    content: [{ type: "text", text: result.message }],
+    structuredContent: {
+      yourAgentId: agentId,
+      ...result,
+    },
+  };
+}
+
+export const registerCancelTaskTool = (server: McpServer) => {
+  createToolRegistrar(server)(
+    "cancel-task",
+    {
+      title: "Cancel Task",
+      description:
+        "Cancel a task that is pending or in progress. Only the lead or task creator can cancel tasks. The worker will be notified via hooks.",
+      annotations: { destructiveHint: true },
+      inputSchema: cancelTaskInputSchema,
+      outputSchema: cancelTaskOutputSchema,
     },
+    async (args, info, _meta) => cancelTaskHandler(ownerCtx(info), args),
   );
 };

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

@@ -1,4 +1,5 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import * as z from "zod";
 import {
   getLogsByTaskIdChronological,
@@ -6,9 +7,78 @@ import {
   getTaskById,
   getUserById,
 } from "@/be/db";
+import { assertOwnsTask, ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import { createToolRegistrar } from "@/tools/utils";
 import { AgentLogSchema, AgentTaskSchema, TaskAttachmentSchema } from "@/types";
 
+export const getTaskDetailsInputSchema = z.object({
+  taskId: z.uuid().describe("The ID of the task to get details for."),
+});
+
+export const getTaskDetailsOutputSchema = z.object({
+  yourAgentId: z.string().uuid().optional(),
+  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(),
+  attachments: z
+    .array(TaskAttachmentSchema)
+    .optional()
+    .describe(
+      "Pointer-based artifacts attached to this task via store-progress, ordered by created_at.",
+    ),
+});
+
+type GetTaskDetailsArgs = z.infer<typeof getTaskDetailsInputSchema>;
+
+export async function getTaskDetailsHandler(
+  ctx: ToolCtx,
+  { taskId }: GetTaskDetailsArgs,
+): Promise<CallToolResult> {
+  const task = getTaskById(taskId);
+  const agentId = ctx.kind === "owner" ? ctx.agentId : undefined;
+
+  if (!task) {
+    return {
+      content: [{ type: "text", text: `Task with ID "${taskId}" not found.` }],
+      structuredContent: {
+        yourAgentId: agentId,
+        success: false,
+        message: `Task with ID "${taskId}" not found.`,
+      },
+    };
+  }
+
+  const ownershipError = assertOwnsTask(ctx, task);
+  if (ownershipError) return ownershipError;
+
+  const logs = getLogsByTaskIdChronological(taskId);
+  const attachments = getTaskAttachments(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: {
+      yourAgentId: agentId,
+      success: true,
+      message: `Task "${taskId}" details retrieved.`,
+      task,
+      requestedBy,
+      logs,
+      attachments,
+    },
+  };
+}
+
 export const registerGetTaskDetailsTool = (server: McpServer) => {
   createToolRegistrar(server)(
     "get-task-details",
@@ -17,65 +87,9 @@ export const registerGetTaskDetailsTool = (server: McpServer) => {
       description:
         "Returns detailed information about a specific task, including output, failure reason, and log history.",
       annotations: { readOnlyHint: true },
-
-      inputSchema: z.object({
-        taskId: z.uuid().describe("The ID of the task to get details for."),
-      }),
-      outputSchema: z.object({
-        yourAgentId: z.string().uuid().optional(),
-        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(),
-        attachments: z
-          .array(TaskAttachmentSchema)
-          .optional()
-          .describe(
-            "Pointer-based artifacts attached to this task via store-progress, ordered by created_at.",
-          ),
-      }),
-    },
-    async ({ taskId }, requestInfo, _meta) => {
-      const task = getTaskById(taskId);
-
-      if (!task) {
-        return {
-          content: [{ type: "text", text: `Task with ID "${taskId}" not found.` }],
-          structuredContent: {
-            yourAgentId: requestInfo.agentId,
-            success: false,
-            message: `Task with ID "${taskId}" not found.`,
-          },
-        };
-      }
-
-      const logs = getLogsByTaskIdChronological(taskId);
-      const attachments = getTaskAttachments(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: {
-          yourAgentId: requestInfo.agentId,
-          success: true,
-          message: `Task "${taskId}" details retrieved.`,
-          task,
-          requestedBy,
-          logs,
-          attachments,
-        },
-      };
+      inputSchema: getTaskDetailsInputSchema,
+      outputSchema: getTaskDetailsOutputSchema,
     },
+    async (args, info, _meta) => getTaskDetailsHandler(ownerCtx(info), args),
   );
 };

package/src/tools/get-tasks.ts

@@ -1,6 +1,8 @@
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import type { CallToolResult } from "@modelcontextprotocol/sdk/types.js";
 import * as z from "zod";
 import { getAllTasks } from "@/be/db";
+import { ownerCtx, type ToolCtx } from "@/tools/task-tool-ctx";
 import { createToolRegistrar } from "@/tools/utils";
 import type { AgentTask, AgentTaskSummary } from "@/types";
 import { AgentTaskStatusSchema } from "@/types";
@@ -24,6 +26,135 @@ const TaskSummarySchema = z.object({
   progress: z.string().optional(),
 });
 
+export const getTasksInputSchema = z.object({
+  status: AgentTaskStatusSchema.optional().describe(
+    "Filter by task status (unassigned, offered, pending, in_progress, completed, failed).",
+  ),
+  mineOnly: z.boolean().optional().describe("Only return tasks assigned to you."),
+  unassigned: z.boolean().optional().describe("Only return unassigned tasks in the pool."),
+  offeredToMe: z
+    .boolean()
+    .optional()
+    .describe("Only return tasks offered to you (awaiting accept/reject)."),
+  readyOnly: z.boolean().optional().describe("Only return tasks whose dependencies are met."),
+  taskType: z.string().optional().describe("Filter by task type (e.g., 'bug', 'feature')."),
+  tags: z.array(z.string()).optional().describe("Filter by any matching tag."),
+  search: z.string().optional().describe("Search in task description."),
+  scheduleId: z
+    .string()
+    .uuid()
+    .optional()
+    .describe("Filter by schedule ID to find tasks created by a specific schedule."),
+  includeHeartbeat: z
+    .boolean()
+    .optional()
+    .describe("Include heartbeat/system tasks in results (excluded by default)."),
+  limit: z
+    .number()
+    .int()
+    .min(1)
+    .max(100)
+    .optional()
+    .describe("Max tasks to return (default: 25, max: 100)."),
+  includeFull: z
+    .boolean()
+    .optional()
+    .describe("Return the full `task` text instead of a ~300-char `taskPreview`. Default false."),
+});
+
+export const getTasksOutputSchema = z.object({
+  yourAgentId: z.string().uuid().optional(),
+  tasks: z.array(TaskSummarySchema),
+});
+
+type GetTasksArgs = z.infer<typeof getTasksInputSchema>;
+
+export async function getTasksHandler(
+  ctx: ToolCtx,
+  {
+    status,
+    mineOnly,
+    unassigned,
+    offeredToMe,
+    readyOnly,
+    taskType,
+    tags,
+    search,
+    scheduleId,
+    includeHeartbeat,
+    limit,
+    includeFull,
+  }: GetTasksArgs,
+): Promise<CallToolResult> {
+  const agentId = ctx.kind === "owner" ? ctx.agentId : undefined;
+
+  // Build filters. User context is hard-scoped by requestedByUserId and ignores
+  // agent-specific shortcuts like mineOnly/offeredToMe.
+  const taskFilters = {
+    status,
+    agentId: ctx.kind === "owner" && mineOnly ? (agentId ?? undefined) : undefined,
+    unassigned: ctx.kind === "owner" ? unassigned : undefined,
+    offeredTo: ctx.kind === "owner" && offeredToMe ? (agentId ?? undefined) : undefined,
+    readyOnly,
+    taskType,
+    tags,
+    search,
+    scheduleId,
+    includeHeartbeat,
+    limit,
+    requestedByUserId: ctx.kind === "user" ? ctx.userId : undefined,
+  };
+  // Default to slim rows (full `task` text → ~300-char `taskPreview`).
+  const tasks: Array<AgentTask | AgentTaskSummary> = includeFull
+    ? getAllTasks(taskFilters)
+    : getAllTasks(taskFilters, { slim: true });
+
+  // Slim rows carry a truncated `task`; surface it as `taskPreview` so the
+  // agent knows it is truncated. `includeFull` returns the full `task`.
+  const taskSummaries = tasks.map((t) => ({
+    id: t.id,
+    agentId: t.agentId,
+    ...(includeFull ? { task: t.task } : { taskPreview: t.task }),
+    status: t.status,
+    taskType: t.taskType,
+    tags: t.tags,
+    priority: t.priority,
+    dependsOn: t.dependsOn,
+    offeredTo: t.offeredTo,
+    createdAt: t.createdAt,
+    lastUpdatedAt: t.lastUpdatedAt,
+    finishedAt: t.finishedAt,
+    progress: t.progress,
+  }));
+
+  // Build filter description for message
+  const filters: string[] = [];
+  if (status) filters.push(`status='${status}'`);
+  if (ctx.kind === "owner" && mineOnly) filters.push("mine only");
+  if (ctx.kind === "owner" && unassigned) filters.push("unassigned");
+  if (ctx.kind === "owner" && offeredToMe) filters.push("offered to me");
+  if (readyOnly) filters.push("ready only");
+  if (taskType) filters.push(`type='${taskType}'`);
+  if (tags?.length) filters.push(`tags=[${tags.join(", ")}]`);
+  if (search) filters.push(`search='${search}'`);
+  if (scheduleId) filters.push(`scheduleId='${scheduleId}'`);
+
+  const filterMsg = filters.length > 0 ? ` (${filters.join(", ")})` : "";
+
+  return {
+    content: [
+      {
+        type: "text",
+        text: `Found ${taskSummaries.length} task(s)${filterMsg}.`,
+      },
+    ],
+    structuredContent: {
+      yourAgentId: agentId,
+      tasks: taskSummaries,
+    },
+  };
+}
+
 export const registerGetTasksTool = (server: McpServer) => {
   createToolRegistrar(server)(
     "get-tasks",
@@ -32,132 +163,9 @@ export const registerGetTasksTool = (server: McpServer) => {
       description:
         "Returns a list of tasks in the swarm with various filters. Sorted by priority (desc) then lastUpdatedAt (desc). Each row carries a `taskPreview` (~300 chars) — enough to pool-triage; pass includeFull:true (or call `get-task-details` by id) for the full `task` text.",
       annotations: { readOnlyHint: true },
-
-      inputSchema: z.object({
-        status: AgentTaskStatusSchema.optional().describe(
-          "Filter by task status (unassigned, offered, pending, in_progress, completed, failed).",
-        ),
-        mineOnly: z.boolean().optional().describe("Only return tasks assigned to you."),
-        unassigned: z.boolean().optional().describe("Only return unassigned tasks in the pool."),
-        offeredToMe: z
-          .boolean()
-          .optional()
-          .describe("Only return tasks offered to you (awaiting accept/reject)."),
-        readyOnly: z.boolean().optional().describe("Only return tasks whose dependencies are met."),
-        taskType: z.string().optional().describe("Filter by task type (e.g., 'bug', 'feature')."),
-        tags: z.array(z.string()).optional().describe("Filter by any matching tag."),
-        search: z.string().optional().describe("Search in task description."),
-        scheduleId: z
-          .string()
-          .uuid()
-          .optional()
-          .describe("Filter by schedule ID to find tasks created by a specific schedule."),
-        includeHeartbeat: z
-          .boolean()
-          .optional()
-          .describe("Include heartbeat/system tasks in results (excluded by default)."),
-        limit: z
-          .number()
-          .int()
-          .min(1)
-          .max(100)
-          .optional()
-          .describe("Max tasks to return (default: 25, max: 100)."),
-        includeFull: z
-          .boolean()
-          .optional()
-          .describe(
-            "Return the full `task` text instead of a ~300-char `taskPreview`. Default false.",
-          ),
-      }),
-      outputSchema: z.object({
-        yourAgentId: z.string().uuid().optional(),
-        tasks: z.array(TaskSummarySchema),
-      }),
-    },
-    async (
-      {
-        status,
-        mineOnly,
-        unassigned,
-        offeredToMe,
-        readyOnly,
-        taskType,
-        tags,
-        search,
-        scheduleId,
-        includeHeartbeat,
-        limit,
-        includeFull,
-      },
-      requestInfo,
-      _meta,
-    ) => {
-      const agentId = requestInfo.agentId;
-
-      // Build filters
-      const taskFilters = {
-        status,
-        agentId: mineOnly ? (agentId ?? undefined) : undefined,
-        unassigned,
-        offeredTo: offeredToMe ? (agentId ?? undefined) : undefined,
-        readyOnly,
-        taskType,
-        tags,
-        search,
-        scheduleId,
-        includeHeartbeat,
-        limit,
-      };
-      // Default to slim rows (full `task` text → ~300-char `taskPreview`).
-      const tasks: Array<AgentTask | AgentTaskSummary> = includeFull
-        ? getAllTasks(taskFilters)
-        : getAllTasks(taskFilters, { slim: true });
-
-      // Slim rows carry a truncated `task`; surface it as `taskPreview` so the
-      // agent knows it is truncated. `includeFull` returns the full `task`.
-      const taskSummaries = tasks.map((t) => ({
-        id: t.id,
-        agentId: t.agentId,
-        ...(includeFull ? { task: t.task } : { taskPreview: t.task }),
-        status: t.status,
-        taskType: t.taskType,
-        tags: t.tags,
-        priority: t.priority,
-        dependsOn: t.dependsOn,
-        offeredTo: t.offeredTo,
-        createdAt: t.createdAt,
-        lastUpdatedAt: t.lastUpdatedAt,
-        finishedAt: t.finishedAt,
-        progress: t.progress,
-      }));
-
-      // Build filter description for message
-      const filters: string[] = [];
-      if (status) filters.push(`status='${status}'`);
-      if (mineOnly) filters.push("mine only");
-      if (unassigned) filters.push("unassigned");
-      if (offeredToMe) filters.push("offered to me");
-      if (readyOnly) filters.push("ready only");
-      if (taskType) filters.push(`type='${taskType}'`);
-      if (tags?.length) filters.push(`tags=[${tags.join(", ")}]`);
-      if (search) filters.push(`search='${search}'`);
-      if (scheduleId) filters.push(`scheduleId='${scheduleId}'`);
-
-      const filterMsg = filters.length > 0 ? ` (${filters.join(", ")})` : "";
-
-      return {
-        content: [
-          {
-            type: "text",
-            text: `Found ${taskSummaries.length} task(s)${filterMsg}.`,
-          },
-        ],
-        structuredContent: {
-          yourAgentId: agentId,
-          tasks: taskSummaries,
-        },
-      };
+      inputSchema: getTasksInputSchema,
+      outputSchema: getTasksOutputSchema,
     },
+    async (args, info, _meta) => getTasksHandler(ownerCtx(info), args),
   );
 };