vellum 0.2.1 → 0.2.7

package/src/tools/subagent/read.ts

@@ -1,98 +1,67 @@
-/**
- * subagent_read tool — read the full output from a completed subagent's conversation.
- */
-
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { getSubagentManager, TERMINAL_STATUSES } from '../../subagent/index.js';
 import { getMessages } from '../../memory/conversation-store.js';
 
-const definition: ToolDefinition = {
-  name: 'subagent_read',
-  description:
-    'Read the full conversation output from a subagent. ' +
-    'Use this after a subagent completes to retrieve its full work product.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      subagent_id: {
-        type: 'string',
-        description: 'The ID of the subagent whose output to read.',
-      },
-    },
-    required: ['subagent_id'],
-  },
-};
-
-export const subagentReadTool: Tool = {
-  name: 'subagent_read',
-  description: definition.description,
-  category: 'orchestration',
-  defaultRiskLevel: RiskLevel.Low,
-
-  getDefinition(): ToolDefinition {
-    return definition;
-  },
-
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const subagentId = input.subagent_id as string;
-    if (!subagentId) {
-      return { content: '"subagent_id" is required.', isError: true };
-    }
+export async function executeSubagentRead(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const subagentId = input.subagent_id as string;
+  if (!subagentId) {
+    return { content: '"subagent_id" is required.', isError: true };
+  }
 
-    const manager = getSubagentManager();
-    const state = manager.getState(subagentId);
-    if (!state) {
-      return { content: `No subagent found with ID "${subagentId}".`, isError: true };
-    }
+  const manager = getSubagentManager();
+  const state = manager.getState(subagentId);
+  if (!state) {
+    return { content: `No subagent found with ID "${subagentId}".`, isError: true };
+  }
 
-    // Ownership check: only the parent session can read a subagent's output.
-    if (state.config.parentSessionId !== context.sessionId) {
-      return { content: `No subagent found with ID "${subagentId}".`, isError: true };
-    }
+  // Ownership check: only the parent session can read a subagent's output.
+  if (state.config.parentSessionId !== context.sessionId) {
+    return { content: `No subagent found with ID "${subagentId}".`, isError: true };
+  }
 
-    if (!TERMINAL_STATUSES.has(state.status)) {
-      return {
-        content: `Subagent "${state.config.label}" is still ${state.status}. Wait for it to finish.`,
-        isError: false,
-      };
-    }
+  if (!TERMINAL_STATUSES.has(state.status)) {
+    return {
+      content: `Subagent "${state.config.label}" is still ${state.status}. Wait for it to finish.`,
+      isError: false,
+    };
+  }
 
-    // Read the subagent's conversation messages from DB.
-    const dbMessages = getMessages(state.conversationId);
-    if (!dbMessages || dbMessages.length === 0) {
-      return { content: 'No messages found in subagent conversation.', isError: true };
-    }
+  // Read the subagent's conversation messages from DB.
+  const dbMessages = getMessages(state.conversationId);
+  if (!dbMessages || dbMessages.length === 0) {
+    return { content: 'No messages found in subagent conversation.', isError: true };
+  }
 
-    // Extract assistant messages only — that's the subagent's output.
-    const output: string[] = [];
-    for (const msg of dbMessages) {
-      if (msg.role !== 'assistant') continue;
-      try {
-        const content = JSON.parse(msg.content);
-        if (Array.isArray(content)) {
-          for (const block of content) {
-            if (block.type === 'text' && typeof block.text === 'string') {
-              output.push(block.text);
-            }
+  // Extract assistant messages only — that's the subagent's output.
+  const output: string[] = [];
+  for (const msg of dbMessages) {
+    if (msg.role !== 'assistant') continue;
+    try {
+      const content = JSON.parse(msg.content);
+      if (Array.isArray(content)) {
+        for (const block of content) {
+          if (block.type === 'text' && typeof block.text === 'string') {
+            output.push(block.text);
           }
-        } else if (typeof content === 'string') {
-          output.push(content);
         }
-      } catch {
-        // Content might be plain text.
-        output.push(msg.content);
+      } else if (typeof content === 'string') {
+        output.push(content);
       }
+    } catch {
+      // Content might be plain text.
+      output.push(msg.content);
     }
+  }
 
-    if (output.length === 0) {
-      return { content: 'Subagent produced no text output.', isError: false };
-    }
+  if (output.length === 0) {
+    return { content: 'Subagent produced no text output.', isError: false };
+  }
 
-    return {
-      content: output.join('\n\n'),
-      isError: false,
-    };
-  },
-};
+  return {
+    content: output.join('\n\n'),
+    isError: false,
+  };
+}

package/src/tools/subagent/spawn.ts

@@ -1,85 +1,46 @@
-/**
- * subagent_spawn tool — lets the parent LLM spawn an autonomous subagent.
- */
-
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { getSubagentManager } from '../../subagent/index.js';
 
-const definition: ToolDefinition = {
-  name: 'subagent_spawn',
-  description:
-    'Spawn an independent subagent to work on a task in parallel. ' +
-    'The subagent runs autonomously and its results are reported back when complete.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      label: {
-        type: 'string',
-        description: 'Short human-readable label for this subagent (e.g. "Research competitor pricing")',
-      },
-      objective: {
-        type: 'string',
-        description: 'The task objective — what the subagent should accomplish',
-      },
-      context: {
-        type: 'string',
-        description: 'Optional additional context to pass to the subagent',
+export async function executeSubagentSpawn(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const label = input.label as string;
+  const objective = input.objective as string;
+  const extraContext = input.context as string | undefined;
+
+  if (!label || !objective) {
+    return { content: 'Both "label" and "objective" are required.', isError: true };
+  }
+
+  const manager = getSubagentManager();
+  const sendToClient = context.sendToClient as ((msg: { type: string; [key: string]: unknown }) => void) | undefined;
+  if (!sendToClient) {
+    return { content: 'No IPC client connected — cannot spawn subagent.', isError: true };
+  }
+
+  try {
+    const subagentId = await manager.spawn(
+      {
+        parentSessionId: context.sessionId,
+        label,
+        objective,
+        context: extraContext,
       },
-    },
-    required: ['label', 'objective'],
-  },
-};
-
-export const subagentSpawnTool: Tool = {
-  name: 'subagent_spawn',
-  description: definition.description,
-  category: 'orchestration',
-  defaultRiskLevel: RiskLevel.Low,
-
-  getDefinition(): ToolDefinition {
-    return definition;
-  },
-
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const label = input.label as string;
-    const objective = input.objective as string;
-    const extraContext = input.context as string | undefined;
-
-    if (!label || !objective) {
-      return { content: 'Both "label" and "objective" are required.', isError: true };
-    }
-
-    const manager = getSubagentManager();
-    const sendToClient = context.sendToClient as ((msg: { type: string; [key: string]: unknown }) => void) | undefined;
-    if (!sendToClient) {
-      return { content: 'No IPC client connected — cannot spawn subagent.', isError: true };
-    }
-
-    try {
-      const subagentId = await manager.spawn(
-        {
-          parentSessionId: context.sessionId,
-          label,
-          objective,
-          context: extraContext,
-        },
-        sendToClient as (msg: unknown) => void,
-      );
-
-      return {
-        content: JSON.stringify({
-          subagentId,
-          label,
-          status: 'pending',
-          message: `Subagent "${label}" spawned. You will be notified automatically when it completes or fails — do NOT poll subagent_status. Continue the conversation normally.`,
-        }),
-        isError: false,
-      };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Failed to spawn subagent: ${msg}`, isError: true };
-    }
-  },
-};
+      sendToClient as (msg: unknown) => void,
+    );
+
+    return {
+      content: JSON.stringify({
+        subagentId,
+        label,
+        status: 'pending',
+        message: `Subagent "${label}" spawned. You will be notified automatically when it completes or fails — do NOT poll subagent_status. Continue the conversation normally.`,
+      }),
+      isError: false,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Failed to spawn subagent: ${msg}`, isError: true };
+  }
+}

package/src/tools/subagent/status.ts

@@ -1,74 +1,45 @@
-/**
- * subagent_status tool — query the status of one or all subagents.
- */
-
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { getSubagentManager } from '../../subagent/index.js';
 
-const definition: ToolDefinition = {
-  name: 'subagent_status',
-  description: 'Get the status of a specific subagent or list all subagents for the current session. Only use this when the user explicitly asks about subagent status — do NOT poll automatically, as you will be notified when subagents complete.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      subagent_id: {
-        type: 'string',
-        description: 'Optional subagent ID to query. If omitted, returns all subagents for this session.',
-      },
-    },
-    required: [],
-  },
-};
-
-export const subagentStatusTool: Tool = {
-  name: 'subagent_status',
-  description: definition.description,
-  category: 'orchestration',
-  defaultRiskLevel: RiskLevel.Low,
-
-  getDefinition(): ToolDefinition {
-    return definition;
-  },
-
-  async execute(input: Record<string, unknown>, context: ToolContext): Promise<ToolExecutionResult> {
-    const subagentId = input.subagent_id as string | undefined;
-    const manager = getSubagentManager();
-
-    if (subagentId) {
-      const state = manager.getState(subagentId);
-      if (!state || state.config.parentSessionId !== context.sessionId) {
-        return { content: `No subagent found with ID "${subagentId}".`, isError: true };
-      }
-      return {
-        content: JSON.stringify({
-          subagentId: state.config.id,
-          label: state.config.label,
-          status: state.status,
-          error: state.error,
-          createdAt: state.createdAt,
-          startedAt: state.startedAt,
-          completedAt: state.completedAt,
-          usage: state.usage,
-        }),
-        isError: false,
-      };
+export async function executeSubagentStatus(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const subagentId = input.subagent_id as string | undefined;
+  const manager = getSubagentManager();
+
+  if (subagentId) {
+    const state = manager.getState(subagentId);
+    if (!state || state.config.parentSessionId !== context.sessionId) {
+      return { content: `No subagent found with ID "${subagentId}".`, isError: true };
     }
-
-    // List all subagents for this parent session.
-    const children = manager.getChildrenOf(context.sessionId);
-    if (children.length === 0) {
-      return { content: 'No subagents found for this session.', isError: false };
-    }
-
-    const summary = children.map((s) => ({
-      subagentId: s.config.id,
-      label: s.config.label,
-      status: s.status,
-      error: s.error,
-    }));
-
-    return { content: JSON.stringify(summary), isError: false };
-  },
-};
+    return {
+      content: JSON.stringify({
+        subagentId: state.config.id,
+        label: state.config.label,
+        status: state.status,
+        error: state.error,
+        createdAt: state.createdAt,
+        startedAt: state.startedAt,
+        completedAt: state.completedAt,
+        usage: state.usage,
+      }),
+      isError: false,
+    };
+  }
+
+  // List all subagents for this parent session.
+  const children = manager.getChildrenOf(context.sessionId);
+  if (children.length === 0) {
+    return { content: 'No subagents found for this session.', isError: false };
+  }
+
+  const summary = children.map((s) => ({
+    subagentId: s.config.id,
+    label: s.config.label,
+    status: s.status,
+    error: s.error,
+  }));
+
+  return { content: JSON.stringify(summary), isError: false };
+}

package/src/tools/swarm/delegate.ts

@@ -3,6 +3,7 @@ import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
 import type { ToolDefinition } from '../../providers/types.js';
 import { getConfig } from '../../config/loader.js';
 import { getLogger } from '../../util/logger.js';
+import { truncate } from '../../util/truncate.js';
 import { getFailoverProvider } from '../../providers/registry.js';
 import { resolveSwarmLimits } from '../../swarm/limits.js';
 import { generatePlan } from '../../swarm/router-planner.js';
@@ -94,7 +95,7 @@ export const swarmDelegateTool: Tool = {
 
       context.onOutput?.(`Plan: ${plan.tasks.length} tasks\n`);
       for (const task of plan.tasks) {
-        context.onOutput?.(`  - [${task.role}] ${task.id}: ${task.objective.slice(0, 80)}\n`);
+        context.onOutput?.(`  - [${task.role}] ${task.id}: ${truncate(task.objective, 80)}\n`);
       }
       context.onOutput?.('\nExecuting...\n');
 

package/src/tools/tasks/index.ts

@@ -17,11 +17,11 @@
  * comments, logs, and developer-facing docs.
  */
 
-export { taskSaveTool } from './task-save.js';
-export { taskRunTool } from './task-run.js';
-export { taskListTool } from './task-list.js';
-export { taskDeleteTool } from './task-delete.js';
-export { taskListShowTool } from './work-item-list.js';
-export { taskListAddTool } from './work-item-enqueue.js';
-export { taskListUpdateTool } from './work-item-update.js';
-export { taskListRemoveTool } from './work-item-remove.js';
+export { executeTaskSave } from './task-save.js';
+export { executeTaskRun } from './task-run.js';
+export { executeTaskList } from './task-list.js';
+export { executeTaskDelete } from './task-delete.js';
+export { executeTaskListShow } from './work-item-list.js';
+export { executeTaskListAdd } from './work-item-enqueue.js';
+export { executeTaskListUpdate } from './work-item-update.js';
+export { executeTaskListRemove } from './work-item-remove.js';

package/src/tools/tasks/task-delete.ts

@@ -1,110 +1,82 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { deleteTask, deleteTasks, getTask } from '../../tasks/task-store.js';
 import { removeWorkItemFromQueue } from '../../work-items/work-item-store.js';
 import { getLogger } from '../../util/logger.js';
 
 const log = getLogger('task-delete');
 
-const definition: ToolDefinition = {
-  name: 'task_delete',
-  description: 'Delete one or more task templates by ID. Also removes associated task runs and work items (Tasks).',
-  input_schema: {
-    type: 'object',
-    properties: {
-      task_ids: {
-        type: 'array',
-        items: { type: 'string' },
-        description: 'One or more task IDs to delete.',
-      },
-    },
-    required: ['task_ids'],
-  },
-};
-
-class TaskDeleteTool implements Tool {
-  name = 'task_delete';
-  description = definition.description;
-  category = 'tasks';
-  defaultRiskLevel = RiskLevel.Medium;
-
-  getDefinition(): ToolDefinition {
-    return definition;
+export async function executeTaskDelete(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const raw = input.task_ids;
+  if (!Array.isArray(raw) || raw.length === 0) {
+    return { content: 'Error: task_ids must be a non-empty array of task ID strings', isError: true };
+  }
+  const ids = raw.filter((v): v is string => typeof v === 'string' && v.trim().length > 0);
+  if (ids.length === 0) {
+    return { content: 'Error: task_ids must contain at least one non-empty string', isError: true };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const raw = input.task_ids;
-    if (!Array.isArray(raw) || raw.length === 0) {
-      return { content: 'Error: task_ids must be a non-empty array of task ID strings', isError: true };
-    }
-    const ids = raw.filter((v): v is string => typeof v === 'string' && v.trim().length > 0);
-    if (ids.length === 0) {
-      return { content: 'Error: task_ids must contain at least one non-empty string', isError: true };
-    }
-
-    try {
-      if (ids.length === 1) {
-        const task = getTask(ids[0]);
-        const deleted = deleteTask(ids[0]);
-        if (!deleted) {
-          // The LLM may pass a work item ID instead of a task template ID.
-          // Fall back to removing from the task queue so the user's intent succeeds.
-          const result = removeWorkItemFromQueue(ids[0]);
-          if (result.success) {
-            log.info({ inputId: ids[0], fallback: true, deletedCount: 1 }, 'deleted via work item fallback');
-            return { content: result.message, isError: false };
-          }
-          log.warn({ inputId: ids[0] }, 'no task or work item found for deletion');
-          return { content: `No task template or work item found with ID "${ids[0]}". Use task_list to see task templates or task_list_show to see work items in the queue.`, isError: true };
+  try {
+    if (ids.length === 1) {
+      const task = getTask(ids[0]);
+      const deleted = deleteTask(ids[0]);
+      if (!deleted) {
+        // The LLM may pass a work item ID instead of a task template ID.
+        // Fall back to removing from the task queue so the user's intent succeeds.
+        const result = removeWorkItemFromQueue(ids[0]);
+        if (result.success) {
+          log.info({ inputId: ids[0], fallback: true, deletedCount: 1 }, 'deleted via work item fallback');
+          return { content: result.message, isError: false };
         }
-        log.info({ taskId: ids[0], title: task?.title, deletedCount: 1 }, 'task deleted');
-        return { content: `Deleted task: ${task?.title ?? ids[0]}`, isError: false };
+        log.warn({ inputId: ids[0] }, 'no task or work item found for deletion');
+        return { content: `No task template or work item found with ID "${ids[0]}". Use task_list to see task templates or task_list_show to see work items in the queue.`, isError: true };
       }
+      log.info({ taskId: ids[0], title: task?.title, deletedCount: 1 }, 'task deleted');
+      return { content: `Deleted task: ${task?.title ?? ids[0]}`, isError: false };
+    }
 
-      const taskIds: string[] = [];
-      const taskTitles: string[] = [];
-      const workItemTitles: string[] = [];
+    const taskIds: string[] = [];
+    const taskTitles: string[] = [];
+    const workItemTitles: string[] = [];
 
-      for (const id of ids) {
-        const task = getTask(id);
-        if (task) {
-          taskIds.push(id);
-          taskTitles.push(task.title);
+    for (const id of ids) {
+      const task = getTask(id);
+      if (task) {
+        taskIds.push(id);
+        taskTitles.push(task.title);
+      } else {
+        const result = removeWorkItemFromQueue(id);
+        if (result.success) {
+          log.info({ inputId: id, fallback: true }, 'deleted work item in batch (fallback)');
+          workItemTitles.push(result.title);
         } else {
-          const result = removeWorkItemFromQueue(id);
-          if (result.success) {
-            log.info({ inputId: id, fallback: true }, 'deleted work item in batch (fallback)');
-            workItemTitles.push(result.title);
-          } else {
-            log.warn({ inputId: id }, 'batch delete: no task or work item found');
-          }
+          log.warn({ inputId: id }, 'batch delete: no task or work item found');
         }
       }
+    }
 
-      const taskCount = taskIds.length > 0 ? deleteTasks(taskIds) : 0;
+    const taskCount = taskIds.length > 0 ? deleteTasks(taskIds) : 0;
 
-      if (taskCount === 0 && workItemTitles.length === 0) {
-        log.warn({ inputIds: ids }, 'no matching tasks found to delete');
-        return { content: 'No matching tasks found to delete.', isError: true };
-      }
+    if (taskCount === 0 && workItemTitles.length === 0) {
+      log.warn({ inputIds: ids }, 'no matching tasks found to delete');
+      return { content: 'No matching tasks found to delete.', isError: true };
+    }
 
-      log.info({ deletedTasks: taskCount, deletedWorkItems: workItemTitles.length, totalInput: ids.length }, 'batch delete completed');
+    log.info({ deletedTasks: taskCount, deletedWorkItems: workItemTitles.length, totalInput: ids.length }, 'batch delete completed');
 
-      const lines: string[] = [];
-      if (taskCount > 0) {
-        lines.push(`Deleted ${taskCount} task(s):`, ...taskTitles.map((t) => `- ${t}`));
-      }
-      if (workItemTitles.length > 0) {
-        lines.push(`Removed ${workItemTitles.length} item(s) from the task queue:`, ...workItemTitles.map((t) => `- ${t}`));
-      }
-      return { content: lines.join('\n'), isError: false };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      log.error({ inputIds: ids, error: msg }, 'delete failed');
-      return { content: `Error: ${msg}`, isError: true };
+    const lines: string[] = [];
+    if (taskCount > 0) {
+      lines.push(`Deleted ${taskCount} task(s):`, ...taskTitles.map((t) => `- ${t}`));
+    }
+    if (workItemTitles.length > 0) {
+      lines.push(`Removed ${workItemTitles.length} item(s) from the task queue:`, ...workItemTitles.map((t) => `- ${t}`));
     }
+    return { content: lines.join('\n'), isError: false };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    log.error({ inputIds: ids, error: msg }, 'delete failed');
+    return { content: `Error: ${msg}`, isError: true };
   }
 }
-
-export const taskDeleteTool = new TaskDeleteTool();