vellum 0.2.1 → 0.2.2

package/src/tools/reminder/reminder.ts

@@ -1,6 +1,4 @@
-import { RiskLevel } from '../../permissions/types.js';
-import type { Tool, ToolContext, ToolExecutionResult } from '../types.js';
-import type { ToolDefinition } from '../../providers/types.js';
+import type { ToolExecutionResult } from '../types.js';
 import { formatLocalDate } from '../../schedule/schedule-store.js';
 import {
   insertReminder,
@@ -8,28 +6,9 @@ import {
   cancelReminder,
 } from './reminder-store.js';
 
-function executeReminder(input: Record<string, unknown>): ToolExecutionResult {
-  const action = input.action as string | undefined;
-  if (!action) {
-    return { content: 'Error: action is required', isError: true };
-  }
-
-  switch (action) {
-    case 'create':
-      return createAction(input);
-    case 'list':
-      return listAction();
-    case 'cancel':
-      return cancelAction(input);
-    default:
-      return {
-        content: `Error: Unknown action "${action}". Valid actions: create, list, cancel`,
-        isError: true,
-      };
-  }
-}
+// ── Exported execute functions ──────────────────────────────────────
 
-function createAction(input: Record<string, unknown>): ToolExecutionResult {
+export function executeReminderCreate(input: Record<string, unknown>): ToolExecutionResult {
   const fireAtStr = input.fire_at as string | undefined;
   const label = input.label as string | undefined;
   const message = input.message as string | undefined;
@@ -68,7 +47,7 @@ function createAction(input: Record<string, unknown>): ToolExecutionResult {
   };
 }
 
-function listAction(): ToolExecutionResult {
+export function executeReminderList(): ToolExecutionResult {
   const all = listReminders();
   if (all.length === 0) {
     return { content: 'No reminders found.', isError: false };
@@ -86,7 +65,7 @@ function listAction(): ToolExecutionResult {
   return { content: `Reminders:\n${lines.join('\n')}`, isError: false };
 }
 
-function cancelAction(input: Record<string, unknown>): ToolExecutionResult {
+export function executeReminderCancel(input: Record<string, unknown>): ToolExecutionResult {
   const reminderId = input.reminder_id as string | undefined;
   if (!reminderId) {
     return { content: 'Error: reminder_id is required for cancel', isError: true };
@@ -99,55 +78,3 @@ function cancelAction(input: Record<string, unknown>): ToolExecutionResult {
 
   return { content: `Reminder "${reminderId}" cancelled.`, isError: false };
 }
-
-class ReminderTool implements Tool {
-  name = 'reminder';
-  description = 'Create, list, or cancel one-time time-based reminders. Reminders fire at a specific future time and either notify the user or execute a message through the assistant. Use this ONLY when the user wants a time-triggered notification (e.g. "remind me at 3pm", "remind me in 2 hours"). Do NOT use this for "add to my tasks" or "add to my queue" — use task_list_add for those requests.';
-  category = 'reminder';
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          action: {
-            type: 'string',
-            enum: ['create', 'list', 'cancel'],
-            description: 'Reminder action',
-          },
-          fire_at: {
-            type: 'string',
-            description: 'ISO 8601 timestamp for when the reminder should fire (required for create)',
-          },
-          label: {
-            type: 'string',
-            description: 'Human-readable label (required for create)',
-          },
-          message: {
-            type: 'string',
-            description: 'Content shown in notification (notify) or sent to agent (execute). Required for create.',
-          },
-          mode: {
-            type: 'string',
-            enum: ['notify', 'execute'],
-            description: 'How the reminder fires. Defaults to notify.',
-          },
-          reminder_id: {
-            type: 'string',
-            description: 'Reminder ID (required for cancel)',
-          },
-        },
-        required: ['action'],
-      },
-    };
-  }
-
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    return executeReminder(input);
-  }
-}
-
-export const reminderTool = new ReminderTool();

package/src/tools/schedule/create.ts

@@ -1,86 +1,81 @@
-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 { createSchedule, isValidCronExpression, formatLocalDate, describeCronExpression } from '../../schedule/schedule-store.js';
+import { normalizeScheduleSyntax } from '../../schedule/recurrence-types.js';
+import { validateRruleSetLines } from '../../schedule/recurrence-engine.js';
 
-class ScheduleCreateTool implements Tool {
-  name = 'schedule_create';
-  description = 'Create a recurring scheduled automation that sends a message at a cron interval. ONLY use this when the user explicitly wants something to run on a schedule (e.g. "every day at 9am", "weekly on Mondays", "every hour"). Do NOT use this for "add to my tasks" or "add to my queue" — use task_list_add for those requests instead.';
-  category = 'schedule';
-  defaultRiskLevel = RiskLevel.Medium;
+export async function executeScheduleCreate(
+  input: Record<string, unknown>,
+  _context: ToolContext,
+): Promise<ToolExecutionResult> {
+  const name = input.name as string;
+  const timezone = (input.timezone as string) ?? null;
+  const message = input.message as string;
+  const enabled = (input.enabled as boolean) ?? true;
 
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: 'object',
-        properties: {
-          name: {
-            type: 'string',
-            description: 'A human-readable name for the scheduled task',
-          },
-          cron_expression: {
-            type: 'string',
-            description: 'A cron expression (e.g. "0 9 * * 1-5" for weekdays at 9am). Supports standard 5-field cron syntax.',
-          },
-          timezone: {
-            type: 'string',
-            description: 'IANA timezone (e.g. "America/Los_Angeles"). Defaults to system timezone if omitted.',
-          },
-          message: {
-            type: 'string',
-            description: 'The message to send to the assistant when the schedule triggers',
-          },
-          enabled: {
-            type: 'boolean',
-            description: 'Whether the job is enabled immediately. Defaults to true.',
-          },
-        },
-        required: ['name', 'cron_expression', 'message'],
-      },
-    };
+  if (!name || typeof name !== 'string') {
+    return { content: 'Error: name is required and must be a string', isError: true };
+  }
+  if (!message || typeof message !== 'string') {
+    return { content: 'Error: message is required and must be a string', isError: true };
   }
 
-  async execute(input: Record<string, unknown>, _context: ToolContext): Promise<ToolExecutionResult> {
-    const name = input.name as string;
-    const cronExpression = input.cron_expression as string;
-    const timezone = (input.timezone as string) ?? null;
-    const message = input.message as string;
-    const enabled = (input.enabled as boolean) ?? true;
+  // Resolve syntax and expression from new or legacy fields
+  const resolved = normalizeScheduleSyntax({
+    syntax: input.syntax as 'cron' | 'rrule' | undefined,
+    expression: input.expression as string | undefined,
+    legacyCronExpression: input.cron_expression as string | undefined,
+  });
 
-    if (!name || typeof name !== 'string') {
-      return { content: 'Error: name is required and must be a string', isError: true };
-    }
-    if (!cronExpression || typeof cronExpression !== 'string') {
-      return { content: 'Error: cron_expression is required and must be a string', isError: true };
-    }
-    if (!message || typeof message !== 'string') {
-      return { content: 'Error: message is required and must be a string', isError: true };
-    }
-    if (!isValidCronExpression(cronExpression)) {
-      return { content: `Error: Invalid cron expression: "${cronExpression}"`, isError: true };
-    }
+  if (!resolved) {
+    return { content: 'Error: expression (or cron_expression) is required', isError: true };
+  }
 
-    try {
-      const job = createSchedule({ name, cronExpression, timezone, message, enabled });
-      const nextRunDate = formatLocalDate(job.nextRunAt);
+  // Syntax-specific pre-validation for actionable error messages
+  if (resolved.syntax === 'cron' && !isValidCronExpression(resolved.expression)) {
+    return { content: `Error: Invalid cron expression: "${resolved.expression}"`, isError: true };
+  }
+  if (resolved.syntax === 'rrule') {
+    if (typeof resolved.expression !== 'string') {
+      return { content: 'Error: expression must be a string', isError: true };
+    }
+    const setError = validateRruleSetLines(resolved.expression);
+    if (setError) {
       return {
-        content: [
-          `Schedule created successfully.`,
-          `  Name: ${job.name}`,
-          `  Schedule: ${describeCronExpression(job.cronExpression)}${job.timezone ? ` (${job.timezone})` : ''}`,
-          `  Enabled: ${job.enabled}`,
-          `  Next run: ${nextRunDate}`,
-        ].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 creating schedule: ${msg}`, isError: true };
     }
   }
-}
 
-registerTool(new ScheduleCreateTool());
+  try {
+    const job = createSchedule({
+      name,
+      cronExpression: resolved.expression,
+      timezone,
+      message,
+      enabled,
+      syntax: resolved.syntax,
+      expression: resolved.expression,
+    });
+
+    const scheduleDescription = job.syntax === 'rrule'
+      ? job.expression
+      : describeCronExpression(job.cronExpression);
+
+    const nextRunDate = formatLocalDate(job.nextRunAt);
+    return {
+      content: [
+        `Schedule created successfully.`,
+        `  Name: ${job.name}`,
+        `  Syntax: ${job.syntax}`,
+        `  Schedule: ${scheduleDescription}${job.timezone ? ` (${job.timezone})` : ''}`,
+        `  Enabled: ${job.enabled}`,
+        `  Next run: ${nextRunDate}`,
+      ].join('\n'),
+      isError: false,
+    };
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error creating schedule: ${msg}`, isError: true };
+  }
+}

package/src/tools/schedule/delete.ts

@@ -1,54 +1,28 @@
-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 { deleteSchedule, getSchedule } from '../../schedule/schedule-store.js';
 
-class ScheduleDeleteTool implements Tool {
-  name = 'schedule_delete';
-  description = 'Delete a recurring scheduled automation and all its run history';
-  category = 'schedule';
-  defaultRiskLevel = RiskLevel.High;
-
-  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 delete',
-          },
-        },
-        required: ['job_id'],
-      },
-    };
+export async function executeScheduleDelete(
+  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 };
-    }
-
-    // Fetch the job first for the confirmation message
-    const job = getSchedule(jobId);
-    if (!job) {
-      return { content: `Error: Schedule not found: ${jobId}`, isError: true };
-    }
-
-    const deleted = deleteSchedule(jobId);
-    if (!deleted) {
-      return { content: `Error: Failed to delete schedule: ${jobId}`, isError: true };
-    }
+  // Fetch the job first for the confirmation message
+  const job = getSchedule(jobId);
+  if (!job) {
+    return { content: `Error: Schedule not found: ${jobId}`, isError: true };
+  }
 
-    return {
-      content: `Schedule deleted: "${job.name}"`,
-      isError: false,
-    };
+  const deleted = deleteSchedule(jobId);
+  if (!deleted) {
+    return { content: `Error: Failed to delete schedule: ${jobId}`, isError: true };
   }
-}
 
-registerTool(new ScheduleDeleteTool());
+  return {
+    content: `Schedule deleted: "${job.name}"`,
+    isError: false,
+  };
+}

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