@vellumai/assistant 0.4.44 → 0.4.45

package/src/tools/network/web-fetch.ts

@@ -763,6 +763,11 @@ export async function executeWebFetch(
         `start_index (${startIndex}) exceeded available content length (${processed.length}).`,
       );
     }
+    if (html && !rawMode && processed.length < 200) {
+      notices.push(
+        `Extracted text content is very short (${processed.length} characters). The page may require JavaScript rendering for full content.`,
+      );
+    }
 
     const content = formatWebFetchOutput({
       requestedUrl: safeRequestedUrl,
@@ -877,4 +882,5 @@ class WebFetchTool implements Tool {
   }
 }
 
-registerTool(new WebFetchTool());
+export const webFetchTool = new WebFetchTool();
+registerTool(webFetchTool);

package/src/tools/network/web-search.ts

@@ -382,4 +382,5 @@ class WebSearchTool implements Tool {
   }
 }
 
-registerTool(new WebSearchTool());
+export const webSearchTool = new WebSearchTool();
+registerTool(webSearchTool);

package/src/tools/registry.ts

@@ -239,6 +239,18 @@ export function registerMcpTools(newTools: Tool[]): Tool[] {
   return accepted;
 }
 
+/**
+ * Unregister all MCP-origin tools from the registry.
+ */
+export function unregisterAllMcpTools(): void {
+  for (const [name, tool] of tools) {
+    if (tool.origin === "mcp") {
+      tools.delete(name);
+      log.info({ name }, "MCP tool unregistered (reload)");
+    }
+  }
+}
+
 /**
  * Unregister all tools belonging to a specific MCP server.
  */
@@ -260,6 +272,17 @@ export function getMcpToolNames(): string[] {
     .map((t) => t.name);
 }
 
+/**
+ * Return tool definitions for all currently registered MCP-origin tools.
+ * Used by the session resolver to dynamically pick up MCP tools that
+ * were registered after session creation (e.g. via `vellum mcp reload`).
+ */
+export function getMcpToolDefinitions(): ToolDefinition[] {
+  return Array.from(tools.values())
+    .filter((t) => t.origin === "mcp")
+    .map((t) => t.getDefinition());
+}
+
 /**
  * Return the names of all currently registered skill-origin tools.
  */

package/src/tools/schedule/create.ts

@@ -1,6 +1,10 @@
 import { formatIntegrationSummary } from "../../schedule/integration-status.js";
 import { validateRruleSetLines } from "../../schedule/recurrence-engine.js";
 import { normalizeScheduleSyntax } from "../../schedule/recurrence-types.js";
+import type {
+  RoutingIntent,
+  ScheduleMode,
+} from "../../schedule/schedule-store.js";
 import {
   createSchedule,
   describeCronExpression,
@@ -9,6 +13,13 @@ import {
 } from "../../schedule/schedule-store.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
 
+const VALID_MODES: ScheduleMode[] = ["notify", "execute"];
+const VALID_ROUTING_INTENTS: RoutingIntent[] = [
+  "single_channel",
+  "multi_channel",
+  "all_channels",
+];
+
 export async function executeScheduleCreate(
   input: Record<string, unknown>,
   _context: ToolContext,
@@ -17,6 +28,12 @@ export async function executeScheduleCreate(
   const timezone = (input.timezone as string) ?? null;
   const message = input.message as string;
   const enabled = (input.enabled as boolean) ?? true;
+  const fireAt = input.fire_at as string | undefined;
+  const mode = (input.mode as ScheduleMode | undefined) ?? "execute";
+  const routingIntent = input.routing_intent as string | undefined;
+  const routingHints = input.routing_hints as
+    | Record<string, unknown>
+    | undefined;
 
   if (!name || typeof name !== "string") {
     return {
@@ -31,6 +48,90 @@ export async function executeScheduleCreate(
     };
   }
 
+  // Validate mode
+  if (!VALID_MODES.includes(mode)) {
+    return {
+      content: `Error: mode must be one of: ${VALID_MODES.join(", ")}`,
+      isError: true,
+    };
+  }
+
+  // Validate routing_intent
+  if (
+    routingIntent !== undefined &&
+    !VALID_ROUTING_INTENTS.includes(routingIntent as RoutingIntent)
+  ) {
+    return {
+      content: `Error: routing_intent must be one of: ${VALID_ROUTING_INTENTS.join(", ")}`,
+      isError: true,
+    };
+  }
+
+  // ── One-shot schedule (fire_at) ──────────────────────────────────
+  if (fireAt) {
+    const fireAtMs = Date.parse(fireAt);
+    if (isNaN(fireAtMs)) {
+      return {
+        content:
+          "Error: fire_at must be a valid ISO 8601 timestamp (e.g. 2025-06-15T09:00:00Z)",
+        isError: true,
+      };
+    }
+    // Require explicit timezone (Z, ±HH:MM, or ±HHMM offset) to avoid host-timezone ambiguity
+    if (!/(?:Z|[+-]\d{2}:?\d{2})\s*$/.test(fireAt)) {
+      return {
+        content:
+          "Error: fire_at must include a timezone offset (e.g. 2025-06-15T09:00:00Z or 2025-06-15T09:00:00+05:30)",
+        isError: true,
+      };
+    }
+    if (fireAtMs <= Date.now()) {
+      return {
+        content: "Error: fire_at must be in the future",
+        isError: true,
+      };
+    }
+
+    try {
+      const job = createSchedule({
+        name,
+        cronExpression: null,
+        timezone,
+        message,
+        enabled,
+        syntax: "cron",
+        expression: null,
+        nextRunAt: fireAtMs,
+        mode,
+        routingIntent: routingIntent as RoutingIntent | undefined,
+        routingHints,
+      });
+
+      const fireDate = formatLocalDate(job.nextRunAt);
+      const integrations = formatIntegrationSummary();
+      return {
+        content: [
+          `One-shot schedule created successfully.`,
+          `  ID: ${job.id}`,
+          `  Name: ${job.name}`,
+          `  Type: one-shot`,
+          `  Mode: ${job.mode}`,
+          `  Fire at: ${fireDate}`,
+          `  Enabled: ${job.enabled}`,
+          `  Status: ${job.status}`,
+          ``,
+          `Integrations: ${integrations}`,
+          `\u26a0 If this schedule requires an integration that isn't connected, it will fail at runtime. Warn the user about any missing capabilities before confirming the schedule is ready.`,
+        ].join("\n"),
+        isError: false,
+      };
+    } catch (err) {
+      const msg = err instanceof Error ? err.message : String(err);
+      return { content: `Error creating schedule: ${msg}`, isError: true };
+    }
+  }
+
+  // ── Recurring schedule (expression) ──────────────────────────────
   const resolved = normalizeScheduleSyntax({
     syntax: input.syntax as "cron" | "rrule" | undefined,
     expression: input.expression as string | undefined,
@@ -38,7 +139,8 @@ export async function executeScheduleCreate(
 
   if (!resolved) {
     return {
-      content: "Error: expression is required",
+      content:
+        "Error: expression is required for recurring schedules (or provide fire_at for one-shot)",
       isError: true,
     };
   }
@@ -75,21 +177,27 @@ export async function executeScheduleCreate(
       enabled,
       syntax: resolved.syntax,
       expression: resolved.expression,
+      mode,
+      routingIntent: routingIntent as RoutingIntent | undefined,
+      routingHints,
     });
 
     const scheduleDescription =
-      job.syntax === "rrule"
-        ? job.expression
-        : describeCronExpression(job.cronExpression);
+      job.expression == null
+        ? "One-time"
+        : job.syntax === "rrule"
+          ? job.expression
+          : describeCronExpression(job.cronExpression);
 
     const nextRunDate = formatLocalDate(job.nextRunAt);
     const integrations = formatIntegrationSummary();
     return {
       content: [
-        `Schedule created successfully.`,
+        `Recurring schedule created successfully.`,
         `  ID: ${job.id}`,
         `  Name: ${job.name}`,
         `  Syntax: ${job.syntax}`,
+        `  Mode: ${job.mode}`,
         `  Schedule: ${scheduleDescription}${
           job.timezone ? ` (${job.timezone})` : ""
         }`,

package/src/tools/schedule/list.ts

@@ -10,9 +10,10 @@ import type { ToolContext, ToolExecutionResult } from "../types.js";
 
 function describeSchedule(job: {
   syntax: string;
-  expression: string;
-  cronExpression: string;
+  expression: string | null;
+  cronExpression: string | null;
 }): string {
+  if (job.expression == null) return "One-time";
   if (job.syntax === "rrule") {
     const label = hasSetConstructs(job.expression) ? "[RRULE set] " : "";
     return `${label}${job.expression}`;
@@ -20,6 +21,10 @@ function describeSchedule(job: {
   return describeCronExpression(job.cronExpression);
 }
 
+function isOneShot(job: { expression: string | null }): boolean {
+  return job.expression == null;
+}
+
 export async function executeScheduleList(
   input: Record<string, unknown>,
   _context: ToolContext,
@@ -34,23 +39,51 @@ export async function executeScheduleList(
       return { content: `Error: Schedule not found: ${jobId}`, isError: true };
     }
 
+    const oneShot = isOneShot(job);
+
     const runs = getScheduleRuns(jobId, 5);
     const lines = [
       `Schedule: ${job.name}`,
       `  ID: ${job.id}`,
-      `  Syntax: ${job.syntax}`,
-      `  Expression: ${job.expression}`,
-      `  Schedule: ${describeSchedule(job)}${
-        job.timezone ? ` (${job.timezone})` : ""
-      }`,
+      `  Type: ${oneShot ? "one-shot" : "recurring"}`,
+      `  Mode: ${job.mode}`,
+      `  Status: ${job.status}`,
+    ];
+
+    if (oneShot) {
+      lines.push(`  Fire at: ${formatLocalDate(job.nextRunAt)}`);
+    } else {
+      lines.push(
+        `  Syntax: ${job.syntax}`,
+        `  Expression: ${job.expression ?? "(one-time)"}`,
+        `  Schedule: ${describeSchedule(job)}${
+          job.timezone ? ` (${job.timezone})` : ""
+        }`,
+      );
+    }
+
+    lines.push(
       `  Enabled: ${job.enabled}`,
       `  Message: ${job.message}`,
-      `  Next run: ${formatLocalDate(job.nextRunAt)}`,
+    );
+
+    if (!oneShot) {
+      lines.push(
+        `  Next run: ${formatLocalDate(job.nextRunAt)}`,
+      );
+    }
+
+    lines.push(
       `  Last run: ${job.lastRunAt ? formatLocalDate(job.lastRunAt) : "never"}`,
       `  Last status: ${job.lastStatus ?? "n/a"}`,
       `  Retry count: ${job.retryCount}`,
       `  Created: ${formatLocalDate(job.createdAt)}`,
-    ];
+    );
+
+    // Show routing intent in detail view when not the default
+    if (job.routingIntent !== "all_channels") {
+      lines.push(`  Routing: ${job.routingIntent}`);
+    }
 
     if (runs.length > 0) {
       lines.push("", `Recent runs (${runs.length}):`);
@@ -78,12 +111,21 @@ export async function executeScheduleList(
   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} (id: ${job.id}) ([${
-        job.syntax
-      }] ${describeSchedule(job)}) — next: ${next}`,
-    );
+    const oneShot = isOneShot(job);
+
+    if (oneShot) {
+      const fireTime = formatLocalDate(job.nextRunAt);
+      lines.push(
+        `  - [${status}] ${job.name} (id: ${job.id}) (one-shot, ${job.mode}) — fire at: ${fireTime} [${job.status}]`,
+      );
+    } else {
+      const next = job.enabled ? formatLocalDate(job.nextRunAt) : "n/a";
+      lines.push(
+        `  - [${status}] ${job.name} (id: ${job.id}) ([${
+          job.syntax
+        }] ${describeSchedule(job)}, ${job.mode}) — next: ${next}`,
+      );
+    }
   }
 
   return { content: lines.join("\n"), isError: false };

package/src/tools/schedule/update.ts

@@ -4,13 +4,25 @@ import {
   normalizeScheduleSyntax,
   type ScheduleSyntax,
 } from "../../schedule/recurrence-types.js";
+import type {
+  RoutingIntent,
+  ScheduleMode,
+} from "../../schedule/schedule-store.js";
 import {
   describeCronExpression,
   formatLocalDate,
+  getSchedule,
   updateSchedule,
 } from "../../schedule/schedule-store.js";
 import type { ToolContext, ToolExecutionResult } from "../types.js";
 
+const VALID_MODES: ScheduleMode[] = ["notify", "execute"];
+const VALID_ROUTING_INTENTS: RoutingIntent[] = [
+  "single_channel",
+  "multi_channel",
+  "all_channels",
+];
+
 export async function executeScheduleUpdate(
   input: Record<string, unknown>,
   _context: ToolContext,
@@ -20,12 +32,64 @@ export async function executeScheduleUpdate(
     return { content: "Error: job_id is required", isError: true };
   }
 
+  // Prevent changing a one-shot to recurring or vice versa
+  if (input.expression !== undefined || input.fire_at !== undefined) {
+    const existing = getSchedule(jobId);
+    if (!existing) {
+      return { content: `Error: Schedule not found: ${jobId}`, isError: true };
+    }
+    const isExistingOneShot = existing.expression == null;
+    if (isExistingOneShot && input.expression !== undefined) {
+      return {
+        content:
+          "Error: Cannot change a one-shot schedule to recurring. Delete and recreate instead.",
+        isError: true,
+      };
+    }
+    if (!isExistingOneShot && input.fire_at !== undefined) {
+      return {
+        content:
+          "Error: Cannot change a recurring schedule to one-shot. Delete and recreate instead.",
+        isError: true,
+      };
+    }
+  }
+
   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;
 
+  // Mode validation and pass-through
+  if (input.mode !== undefined) {
+    const mode = input.mode as ScheduleMode;
+    if (!VALID_MODES.includes(mode)) {
+      return {
+        content: `Error: mode must be one of: ${VALID_MODES.join(", ")}`,
+        isError: true,
+      };
+    }
+    updates.mode = mode;
+  }
+
+  // Routing intent validation and pass-through
+  if (input.routing_intent !== undefined) {
+    const routingIntent = input.routing_intent as RoutingIntent;
+    if (!VALID_ROUTING_INTENTS.includes(routingIntent)) {
+      return {
+        content: `Error: routing_intent must be one of: ${VALID_ROUTING_INTENTS.join(", ")}`,
+        isError: true,
+      };
+    }
+    updates.routingIntent = routingIntent;
+  }
+
+  // Routing hints pass-through
+  if (input.routing_hints !== undefined) {
+    updates.routingHints = input.routing_hints;
+  }
+
   // Auto-detect syntax when expression changes without explicit syntax
   if (input.expression !== undefined || input.syntax !== undefined) {
     const resolved = normalizeScheduleSyntax({
@@ -85,6 +149,9 @@ export async function executeScheduleUpdate(
         enabled?: boolean;
         syntax?: ScheduleSyntax;
         expression?: string;
+        mode?: ScheduleMode;
+        routingIntent?: RoutingIntent;
+        routingHints?: Record<string, unknown>;
       },
     );
 
@@ -93,15 +160,18 @@ export async function executeScheduleUpdate(
     }
 
     const scheduleDescription =
-      job.syntax === "rrule"
-        ? job.expression
-        : describeCronExpression(job.cronExpression);
+      job.expression == null
+        ? "One-time"
+        : job.syntax === "rrule"
+          ? job.expression
+          : describeCronExpression(job.cronExpression);
 
     return {
       content: [
         `Schedule updated successfully.`,
         `  Name: ${job.name}`,
         `  Syntax: ${job.syntax}`,
+        `  Mode: ${job.mode}`,
         `  Schedule: ${scheduleDescription}${job.timezone ? ` (${job.timezone})` : ""}`,
         `  Enabled: ${job.enabled}`,
         `  Next run: ${job.enabled ? formatLocalDate(job.nextRunAt) : "n/a (disabled)"}`,

package/src/tools/shared/filesystem/image-read.ts

@@ -0,0 +1,192 @@
+import { execFileSync } from "node:child_process";
+import { readFileSync, statSync, unlinkSync } from "node:fs";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+
+import type { ImageContent } from "../../../providers/types.js";
+import type { ToolExecutionResult } from "../../types.js";
+
+export const IMAGE_EXTENSIONS = new Set([
+  ".jpg",
+  ".jpeg",
+  ".png",
+  ".gif",
+  ".webp",
+]);
+
+const MAX_SIZE_BYTES = 20 * 1024 * 1024; // 20 MB
+
+// Images above this threshold get auto-optimized via sips (macOS) to avoid
+// sending multi-MB base64 payloads to the LLM API.
+const OPTIMIZE_THRESHOLD_BYTES = 1 * 1024 * 1024; // 1 MB
+const OPTIMIZE_MAX_DIMENSION = 1568; // Anthropic's recommended max
+const OPTIMIZE_JPEG_QUALITY = 80;
+
+/**
+ * Detect the actual image format from the first bytes of the buffer.
+ * Returns the MIME type, or null if unrecognised.
+ */
+function detectMediaType(buf: Buffer): string | null {
+  if (buf.length < 12) return null;
+
+  // JPEG: FF D8 FF
+  if (buf[0] === 0xff && buf[1] === 0xd8 && buf[2] === 0xff) {
+    return "image/jpeg";
+  }
+  // PNG: 89 50 4E 47 0D 0A 1A 0A
+  if (
+    buf[0] === 0x89 &&
+    buf[1] === 0x50 &&
+    buf[2] === 0x4e &&
+    buf[3] === 0x47
+  ) {
+    return "image/png";
+  }
+  // GIF: 47 49 46 38
+  if (
+    buf[0] === 0x47 &&
+    buf[1] === 0x49 &&
+    buf[2] === 0x46 &&
+    buf[3] === 0x38
+  ) {
+    return "image/gif";
+  }
+  // WebP: RIFF....WEBP
+  if (
+    buf[0] === 0x52 &&
+    buf[1] === 0x49 &&
+    buf[2] === 0x46 &&
+    buf[3] === 0x46 &&
+    buf[8] === 0x57 &&
+    buf[9] === 0x45 &&
+    buf[10] === 0x42 &&
+    buf[11] === 0x50
+  ) {
+    return "image/webp";
+  }
+
+  return null;
+}
+
+/**
+ * Use macOS `sips` to resize and convert an image to JPEG.
+ * Returns the path to the optimized temp file, or null if sips is unavailable.
+ */
+function optimizeWithSips(srcPath: string): string | null {
+  const tmpPath = join(tmpdir(), `vellum-view-image-${Date.now()}.jpg`);
+  try {
+    execFileSync(
+      "sips",
+      [
+        "--resampleHeightWidthMax",
+        String(OPTIMIZE_MAX_DIMENSION),
+        "-s",
+        "format",
+        "jpeg",
+        "-s",
+        "formatOptions",
+        String(OPTIMIZE_JPEG_QUALITY),
+        srcPath,
+        "--out",
+        tmpPath,
+      ],
+      { stdio: "pipe", timeout: 15_000 },
+    );
+    return tmpPath;
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Read an image file from disk, optionally optimize it, and return a
+ * ToolExecutionResult with base64-encoded image content blocks.
+ *
+ * The caller is responsible for path resolution and sandbox enforcement —
+ * `resolvedPath` must be an already-validated absolute path.
+ */
+export function readImageFile(resolvedPath: string): ToolExecutionResult {
+  let stat;
+  try {
+    stat = statSync(resolvedPath);
+  } catch {
+    return {
+      content: `Error: file not found: ${resolvedPath}`,
+      isError: true,
+    };
+  }
+
+  if (!stat.isFile()) {
+    return { content: `Error: ${resolvedPath} is not a file`, isError: true };
+  }
+
+  if (stat.size > MAX_SIZE_BYTES) {
+    const sizeMB = (stat.size / (1024 * 1024)).toFixed(1);
+    return {
+      content: `Error: image too large (${sizeMB} MB). Maximum is 20 MB.`,
+      isError: true,
+    };
+  }
+
+  let buffer: Buffer;
+  let optimized = false;
+  let tmpPath: string | null = null;
+
+  try {
+    if (stat.size > OPTIMIZE_THRESHOLD_BYTES) {
+      tmpPath = optimizeWithSips(resolvedPath);
+      if (tmpPath) {
+        buffer = readFileSync(tmpPath) as Buffer;
+        optimized = true;
+      } else {
+        buffer = readFileSync(resolvedPath) as Buffer;
+      }
+    } else {
+      buffer = readFileSync(resolvedPath) as Buffer;
+    }
+  } catch (err) {
+    const msg = err instanceof Error ? err.message : String(err);
+    return { content: `Error reading file: ${msg}`, isError: true };
+  } finally {
+    if (tmpPath) {
+      try {
+        unlinkSync(tmpPath);
+      } catch {
+        /* ignore cleanup errors */
+      }
+    }
+  }
+
+  // Detect actual format from magic bytes — never trust the file extension
+  // alone, since sips converts to JPEG and files can be misnamed.
+  const detectedType = detectMediaType(buffer);
+  if (!detectedType) {
+    return {
+      content: `Error: could not detect image format for ${resolvedPath}. The file may be corrupt.`,
+      isError: true,
+    };
+  }
+
+  const base64Data = buffer.toString("base64");
+
+  const imageBlock: ImageContent = {
+    type: "image" as const,
+    source: {
+      type: "base64" as const,
+      media_type: detectedType,
+      data: base64Data,
+    },
+  };
+
+  const sizeSuffix = optimized
+    ? ` (optimized from ${(stat.size / 1024).toFixed(0)} KB to ${(
+        buffer.length / 1024
+      ).toFixed(0)} KB)`
+    : "";
+
+  return {
+    content: `Image loaded: ${resolvedPath} (${buffer.length} bytes, ${detectedType})${sizeSuffix}`,
+    isError: false,
+    contentBlocks: [imageBlock],
+  };
+}

package/src/tools/side-effects.ts

@@ -23,8 +23,6 @@ const SIDE_EFFECT_TOOLS: ReadonlySet<string> = new Set([
   "browser_fill_credential",
   "document_create",
   "document_update",
-  "reminder_create",
-  "reminder_cancel",
   "schedule_create",
   "schedule_update",
   "schedule_delete",
@@ -35,7 +33,7 @@ const SIDE_EFFECT_TOOLS: ReadonlySet<string> = new Set([
  * (i.e. it can modify the filesystem, execute arbitrary commands, or trigger
  * external actions). Read-only and informational tools return `false`.
  *
- * For mixed-action tools (e.g. account_manage, credential_store), the optional
+ * For mixed-action tools (e.g. credential_store), the optional
  * `input` parameter is inspected to distinguish mutating actions (create,
  * update, cancel) from read-only ones (list, get).
  */
@@ -46,10 +44,6 @@ export function isSideEffectTool(
   if (SIDE_EFFECT_TOOLS.has(toolName)) return true;
 
   // Action-aware checks for mixed-action tools
-  if (toolName === "account_manage") {
-    const action = input?.action;
-    return action === "create" || action === "update";
-  }
   if (toolName === "credential_store") {
     const action = input?.action;
     return (