vellum 0.2.1 → 0.2.2

package/src/tools/subagent/abort.ts

@@ -1,62 +1,33 @@
-/**
- * subagent_abort tool — abort a running 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_abort',
-  description: 'Abort a running subagent by ID.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      subagent_id: {
-        type: 'string',
-        description: 'The ID of the subagent to abort.',
-      },
-    },
-    required: ['subagent_id'],
-  },
-};
-
-export const subagentAbortTool: Tool = {
-  name: 'subagent_abort',
-  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 };
-    }
-
-    const manager = getSubagentManager();
-    const sendToClient = context.sendToClient as ((msg: unknown) => void) | undefined;
-    const aborted = manager.abort(
-      subagentId,
-      sendToClient as ((msg: unknown) => void) | undefined,
-      context.sessionId,
-      { suppressNotification: true },
-    );
-
-    if (!aborted) {
-      return {
-        content: `Could not abort subagent "${subagentId}". It may not exist or already be in a terminal state.`,
-        isError: true,
-      };
-    }
-
+export async function executeSubagentAbort(
+  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 sendToClient = context.sendToClient as ((msg: unknown) => void) | undefined;
+  const aborted = manager.abort(
+    subagentId,
+    sendToClient as ((msg: unknown) => void) | undefined,
+    context.sessionId,
+    { suppressNotification: true },
+  );
+
+  if (!aborted) {
     return {
-      content: JSON.stringify({ subagentId, status: 'aborted', message: 'Subagent aborted successfully.' }),
-      isError: false,
+      content: `Could not abort subagent "${subagentId}". It may not exist or already be in a terminal state.`,
+      isError: true,
     };
-  },
-};
+  }
+
+  return {
+    content: JSON.stringify({ subagentId, status: 'aborted', message: 'Subagent aborted successfully.' }),
+    isError: false,
+  };
+}

package/src/tools/subagent/message.ts

@@ -1,72 +1,39 @@
-/**
- * subagent_message tool — send a follow-up message to a running 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_message',
-  description: 'Send a follow-up message to a running subagent.',
-  input_schema: {
-    type: 'object',
-    properties: {
-      subagent_id: {
-        type: 'string',
-        description: 'The ID of the subagent to send a message to.',
-      },
-      content: {
-        type: 'string',
-        description: 'The message content to send to the subagent.',
-      },
-    },
-    required: ['subagent_id', 'content'],
-  },
-};
-
-export const subagentMessageTool: Tool = {
-  name: 'subagent_message',
-  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;
-    const content = input.content as string;
+export async function executeSubagentMessage(
+  input: Record<string, unknown>,
+  context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const subagentId = input.subagent_id as string;
+  const content = input.content as string;
 
-    if (!subagentId || !content) {
-      return { content: 'Both "subagent_id" and "content" are required.', isError: true };
-    }
+  if (!subagentId || !content) {
+    return { content: 'Both "subagent_id" and "content" are required.', isError: true };
+  }
 
-    const manager = getSubagentManager();
+  const manager = getSubagentManager();
 
-    // Ownership check: only the parent session can message a subagent.
-    const state = manager.getState(subagentId);
-    if (!state || state.config.parentSessionId !== context.sessionId) {
-      return {
-        content: `Could not send message to subagent "${subagentId}". It may not exist or be in a terminal state.`,
-        isError: true,
-      };
-    }
-
-    const sent = manager.sendMessage(subagentId, content);
+  // Ownership check: only the parent session can message a subagent.
+  const state = manager.getState(subagentId);
+  if (!state || state.config.parentSessionId !== context.sessionId) {
+    return {
+      content: `Could not send message to subagent "${subagentId}". It may not exist or be in a terminal state.`,
+      isError: true,
+    };
+  }
 
-    if (!sent) {
-      return {
-        content: `Could not send message to subagent "${subagentId}". It may not exist or be in a terminal state.`,
-        isError: true,
-      };
-    }
+  const sent = manager.sendMessage(subagentId, content);
 
+  if (!sent) {
     return {
-      content: JSON.stringify({ subagentId, message: 'Message sent to subagent.' }),
-      isError: false,
+      content: `Could not send message to subagent "${subagentId}". It may not exist or be in a terminal state.`,
+      isError: true,
     };
-  },
-};
+  }
+
+  return {
+    content: JSON.stringify({ subagentId, message: 'Message sent to subagent.' }),
+    isError: false,
+  };
+}

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';