@vellumai/assistant 0.4.43 → 0.4.45

package/src/tools/memory/register.ts

@@ -3,10 +3,8 @@ import { RiskLevel } from "../../permissions/types.js";
 import type { ToolDefinition } from "../../providers/types.js";
 import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
 import {
-  memoryDeleteDefinition,
+  memoryManageDefinition,
   memoryRecallDefinition,
-  memorySaveDefinition,
-  memoryUpdateDefinition,
 } from "./definitions.js";
 import {
   handleMemoryDelete,
@@ -15,16 +13,16 @@ import {
   handleMemoryUpdate,
 } from "./handlers.js";
 
-// ── memory_save ──────────────────────────────────────────────────────
+// ── memory_manage ────────────────────────────────────────────────────
 
-class MemorySaveTool implements Tool {
-  name = "memory_save";
-  description = memorySaveDefinition.description;
+class MemoryManageTool implements Tool {
+  name = "memory_manage";
+  description = memoryManageDefinition.description;
   category = "memory";
   defaultRiskLevel = RiskLevel.Low;
 
   getDefinition(): ToolDefinition {
-    return memorySaveDefinition;
+    return memoryManageDefinition;
   }
 
   async execute(
@@ -32,55 +30,25 @@ class MemorySaveTool implements Tool {
     context: ToolContext,
   ): Promise<ToolExecutionResult> {
     const config = getConfig();
-    return handleMemorySave(
-      input,
-      config,
-      context.conversationId,
-      context.requestId,
-      context.memoryScopeId,
-    );
-  }
-}
-
-// ── memory_update ────────────────────────────────────────────────────
-
-class MemoryUpdateTool implements Tool {
-  name = "memory_update";
-  description = memoryUpdateDefinition.description;
-  category = "memory";
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return memoryUpdateDefinition;
-  }
-
-  async execute(
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolExecutionResult> {
-    const config = getConfig();
-    return handleMemoryUpdate(input, config, context.memoryScopeId);
-  }
-}
-
-// ── memory_delete ────────────────────────────────────────────────────
-
-class MemoryDeleteTool implements Tool {
-  name = "memory_delete";
-  description = memoryDeleteDefinition.description;
-  category = "memory";
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return memoryDeleteDefinition;
-  }
-
-  async execute(
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolExecutionResult> {
-    const config = getConfig();
-    return handleMemoryDelete(input, config, context.memoryScopeId);
+    switch (input.op) {
+      case "save":
+        return handleMemorySave(
+          input,
+          config,
+          context.conversationId,
+          context.requestId,
+          context.memoryScopeId,
+        );
+      case "update":
+        return handleMemoryUpdate(input, config, context.memoryScopeId);
+      case "delete":
+        return handleMemoryDelete(input, config, context.memoryScopeId);
+      default:
+        return {
+          content: `Error: unknown op "${input.op}". Must be one of: save, update, delete`,
+          isError: true,
+        };
+    }
   }
 }
 
@@ -112,7 +80,5 @@ class MemoryRecallTool implements Tool {
 
 // ── Exported tool instances ──────────────────────────────────────────
 
-export const memorySaveTool = new MemorySaveTool();
-export const memoryUpdateTool = new MemoryUpdateTool();
-export const memoryDeleteTool = new MemoryDeleteTool();
+export const memoryManageTool = new MemoryManageTool();
 export const memoryRecallTool = new MemoryRecallTool();

package/src/tools/network/script-proxy/session-manager.ts

@@ -528,15 +528,13 @@ export function getSessionEnv(sessionId: ProxySessionId): ProxyEnvVars {
     NO_PROXY: "localhost,127.0.0.1,::1",
   };
 
-  if (managed.dataDir) {
+  // Only set cert env vars when the CA was actually initialized (MITM mode).
+  // Without this guard, NODE_EXTRA_CA_CERTS points to a nonexistent file
+  // when the proxy runs in pass-through mode (no credentials/MITM),
+  // causing Bun/BoringSSL to fail with SSL load errors.
+  if (managed.dataDir && managed.combinedCABundlePath) {
     env.NODE_EXTRA_CA_CERTS = getCAPath(managed.dataDir);
-    // Combined bundle lets non-Node clients (curl, Python, Go) trust
-    // the proxy CA alongside system roots via SSL_CERT_FILE.
-    // Only set when the bundle was actually created — pointing at a
-    // missing file would replace the system trust store with nothing.
-    if (managed.combinedCABundlePath) {
-      env.SSL_CERT_FILE = managed.combinedCABundlePath;
-    }
+    env.SSL_CERT_FILE = managed.combinedCABundlePath;
   }
 
   return env;

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)"}`,