vellum 0.2.1 → 0.2.7

package/src/tools/schedule/list.ts

@@ -1,88 +1,69 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { listSchedules, getSchedule, getScheduleRuns, formatLocalDate, describeCronExpression } from '../../schedule/schedule-store.js';
+import { hasSetConstructs } from '../../schedule/recurrence-engine.js';
 
-class ScheduleListTool implements Tool {
-  name = 'schedule_list';
-  description = 'List recurring scheduled automations (cron jobs), or show details and recent runs for a specific one. For the user\'s task queue, use task_list_show instead.';
-  category = 'schedule';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          enabled_only: {
-            type: 'boolean',
-            description: 'When true, only show enabled jobs. Defaults to false.',
-          },
-          job_id: {
-            type: 'string',
-            description: 'If provided, show detailed info and recent runs for this specific job.',
-          },
-        },
-        required: [],
-      },
-    };
+function describeSchedule(job: { syntax: string; expression: string; cronExpression: string }): string {
+  if (job.syntax === 'rrule') {
+    const label = hasSetConstructs(job.expression) ? '[RRULE set] ' : '';
+    return `${label}${job.expression}`;
   }
+  return describeCronExpression(job.cronExpression);
+}
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const jobId = input.job_id as string | undefined;
-    const enabledOnly = (input.enabled_only as boolean) ?? false;
+export async function executeScheduleList(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const jobId = input.job_id as string | undefined;
+  const enabledOnly = (input.enabled_only as boolean) ?? false;
 
-    // Detail mode for a specific job
-    if (jobId) {
-      const job = getSchedule(jobId);
-      if (!job) {
-        return { content: `Error: Schedule not found: ${jobId}`, isError: true };
-      }
+  // Detail mode for a specific job
+  if (jobId) {
+    const job = getSchedule(jobId);
+    if (!job) {
+      return { content: `Error: Schedule not found: ${jobId}`, isError: true };
+    }
 
-      const runs = getScheduleRuns(jobId, 5);
-      const lines = [
-        `Schedule: ${job.name}`,
-        `  Schedule: ${describeCronExpression(job.cronExpression)}${job.timezone ? ` (${job.timezone})` : ''}`,
-        `  Enabled: ${job.enabled}`,
-        `  Message: ${job.message}`,
-        `  Next run: ${formatLocalDate(job.nextRunAt)}`,
-        `  Last run: ${job.lastRunAt ? formatLocalDate(job.lastRunAt) : 'never'}`,
-        `  Last status: ${job.lastStatus ?? 'n/a'}`,
-        `  Retry count: ${job.retryCount}`,
-        `  Created: ${formatLocalDate(job.createdAt)}`,
-      ];
+    const runs = getScheduleRuns(jobId, 5);
+    const lines = [
+      `Schedule: ${job.name}`,
+      `  Syntax: ${job.syntax}`,
+      `  Expression: ${job.expression}`,
+      `  Schedule: ${describeSchedule(job)}${job.timezone ? ` (${job.timezone})` : ''}`,
+      `  Enabled: ${job.enabled}`,
+      `  Message: ${job.message}`,
+      `  Next run: ${formatLocalDate(job.nextRunAt)}`,
+      `  Last run: ${job.lastRunAt ? formatLocalDate(job.lastRunAt) : 'never'}`,
+      `  Last status: ${job.lastStatus ?? 'n/a'}`,
+      `  Retry count: ${job.retryCount}`,
+      `  Created: ${formatLocalDate(job.createdAt)}`,
+    ];
 
-      if (runs.length > 0) {
-        lines.push('', `Recent runs (${runs.length}):`);
-        for (const run of runs) {
-          const dur = run.durationMs != null ? `${run.durationMs}ms` : 'n/a';
-          lines.push(`  - ${run.status} at ${formatLocalDate(run.startedAt)} (${dur})${run.error ? ` error: ${run.error}` : ''}`);
-        }
-      } else {
-        lines.push('', 'No runs yet.');
+    if (runs.length > 0) {
+      lines.push('', `Recent runs (${runs.length}):`);
+      for (const run of runs) {
+        const dur = run.durationMs != null ? `${run.durationMs}ms` : 'n/a';
+        lines.push(`  - ${run.status} at ${formatLocalDate(run.startedAt)} (${dur})${run.error ? ` error: ${run.error}` : ''}`);
       }
-
-      return { content: lines.join('\n'), isError: false };
+    } else {
+      lines.push('', 'No runs yet.');
     }
 
-    // List mode
-    const jobs = listSchedules({ enabledOnly });
-    if (jobs.length === 0) {
-      return { content: 'No schedules found.', isError: false };
-    }
+    return { content: lines.join('\n'), isError: false };
+  }
 
-    const lines = [`Schedules (${jobs.length}):`];
-    for (const job of jobs) {
-      const status = job.enabled ? 'enabled' : 'disabled';
-      const next = job.enabled ? formatLocalDate(job.nextRunAt) : 'n/a';
-      lines.push(`  - [${status}] ${job.name} (${describeCronExpression(job.cronExpression)}) — next: ${next}`);
-    }
+  // List mode
+  const jobs = listSchedules({ enabledOnly });
+  if (jobs.length === 0) {
+    return { content: 'No schedules found.', isError: false };
+  }
 
-    return { content: lines.join('\n'), isError: false };
+  const lines = [`Schedules (${jobs.length}):`];
+  for (const job of jobs) {
+    const status = job.enabled ? 'enabled' : 'disabled';
+    const next = job.enabled ? formatLocalDate(job.nextRunAt) : 'n/a';
+    lines.push(`  - [${status}] ${job.name} ([${job.syntax}] ${describeSchedule(job)}) — next: ${next}`);
   }
-}
 
-registerTool(new ScheduleListTool());
+  return { content: lines.join('\n'), isError: false };
+}

package/src/tools/schedule/update.ts

@@ -1,97 +1,90 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
-import { registerTool } from '../registry.js';
+import type { ToolContext, ToolExecutionResult } from '../types.js';
 import { updateSchedule, formatLocalDate, describeCronExpression } from '../../schedule/schedule-store.js';
+import { normalizeScheduleSyntax, type ScheduleSyntax } from '../../schedule/recurrence-types.js';
+import { validateRruleSetLines } from '../../schedule/recurrence-engine.js';
 
-class ScheduleUpdateTool implements Tool {
-  name = 'schedule_update';
-  description = 'Update an existing recurring scheduled automation (cron expression, message, name, or enabled state)';
-  category = 'schedule';
-  defaultRiskLevel = RiskLevel.Medium;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          job_id: {
-            type: 'string',
-            description: 'The ID of the schedule to update',
-          },
-          name: {
-            type: 'string',
-            description: 'New name for the job',
-          },
-          cron_expression: {
-            type: 'string',
-            description: 'New cron expression',
-          },
-          timezone: {
-            type: 'string',
-            description: 'New IANA timezone',
-          },
-          message: {
-            type: 'string',
-            description: 'New message to send when triggered',
-          },
-          enabled: {
-            type: 'boolean',
-            description: 'Enable or disable the job',
-          },
-        },
-        required: ['job_id'],
-      },
-    };
+export async function executeScheduleUpdate(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const jobId = input.job_id as string;
+  if (!jobId || typeof jobId !== 'string') {
+    return { content: 'Error: job_id is required', isError: true };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const jobId = input.job_id as string;
-    if (!jobId || typeof jobId !== 'string') {
-      return { content: 'Error: job_id is required', isError: true };
-    }
-
-    const updates: Record<string, unknown> = {};
-    if (input.name !== undefined) updates.name = input.name;
-    if (input.cron_expression !== undefined) updates.cronExpression = input.cron_expression;
-    if (input.timezone !== undefined) updates.timezone = input.timezone;
-    if (input.message !== undefined) updates.message = input.message;
-    if (input.enabled !== undefined) updates.enabled = input.enabled;
+  const updates: Record<string, unknown> = {};
+  if (input.name !== undefined) updates.name = input.name;
+  if (input.timezone !== undefined) updates.timezone = input.timezone;
+  if (input.message !== undefined) updates.message = input.message;
+  if (input.enabled !== undefined) updates.enabled = input.enabled;
 
-    if (Object.keys(updates).length === 0) {
-      return { content: 'Error: No updates provided. Specify at least one field to update.', isError: true };
+  // Auto-detect syntax when expression changes without explicit syntax
+  const hasExpression = input.expression !== undefined || input.cron_expression !== undefined;
+  if (hasExpression || input.syntax !== undefined) {
+    const resolved = normalizeScheduleSyntax({
+      syntax: input.syntax as 'cron' | 'rrule' | undefined,
+      expression: input.expression as string | undefined,
+      legacyCronExpression: input.cron_expression as string | undefined,
+    });
+    if (resolved) {
+      updates.syntax = resolved.syntax;
+      updates.expression = resolved.expression;
+    } else if (input.expression !== undefined) {
+      updates.expression = input.expression;
+    } else if (input.cron_expression !== undefined) {
+      updates.cronExpression = input.cron_expression;
     }
+  }
 
-    try {
-      const job = updateSchedule(jobId, updates as {
-        name?: string;
-        cronExpression?: string;
-        timezone?: string | null;
-        message?: string;
-        enabled?: boolean;
-      });
-
-      if (!job) {
-        return { content: `Error: Schedule not found: ${jobId}`, isError: true };
-      }
+  if (Object.keys(updates).length === 0) {
+    return { content: 'Error: No updates provided. Specify at least one field to update.', isError: true };
+  }
 
+  // Set-aware pre-validation for RRULE expressions
+  const effectiveSyntax = updates.syntax as string | undefined;
+  const effectiveExpr = (updates.expression as string | undefined) ?? (updates.cronExpression as string | undefined);
+  if (effectiveExpr && typeof effectiveExpr === 'string' && (effectiveSyntax === 'rrule' || /^(DTSTART|RRULE:)/m.test(effectiveExpr))) {
+    const setError = validateRruleSetLines(effectiveExpr);
+    if (setError) {
       return {
-        content: [
-          `Schedule updated successfully.`,
-          `  Name: ${job.name}`,
-          `  Schedule: ${describeCronExpression(job.cronExpression)}${job.timezone ? ` (${job.timezone})` : ''}`,
-          `  Enabled: ${job.enabled}`,
-          `  Next run: ${job.enabled ? formatLocalDate(job.nextRunAt) : 'n/a (disabled)'}`,
-        ].join('\n'),
-        isError: false,
+        content: `Error: ${setError}. Supported line types: DTSTART, RRULE, RDATE, EXDATE, EXRULE.`,
+        isError: true,
       };
-    } catch (err) {
-      const msg = err instanceof Error ? err.message : String(err);
-      return { content: `Error updating schedule: ${msg}`, isError: true };
     }
   }
-}
 
-registerTool(new ScheduleUpdateTool());
+  try {
+    const job = updateSchedule(jobId, updates as {
+      name?: string;
+      cronExpression?: string;
+      timezone?: string | null;
+      message?: string;
+      enabled?: boolean;
+      syntax?: ScheduleSyntax;
+      expression?: string;
+    });
+
+    if (!job) {
+      return { content: `Error: Schedule not found: ${jobId}`, isError: true };
+    }
+
+    const scheduleDescription = job.syntax === 'rrule'
+      ? job.expression
+      : describeCronExpression(job.cronExpression);
+
+    return {
+      content: [
+        `Schedule updated successfully.`,
+        `  Name: ${job.name}`,
+        `  Syntax: ${job.syntax}`,
+        `  Schedule: ${scheduleDescription}${job.timezone ? ` (${job.timezone})` : ''}`,
+        `  Enabled: ${job.enabled}`,
+        `  Next run: ${job.enabled ? formatLocalDate(job.nextRunAt) : 'n/a (disabled)'}`,
+      ].join('\n'),
+      isError: false,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error updating schedule: ${msg}`, isError: true };
+  }
+}

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,
+  };
+}