@vellumai/assistant 0.4.44 → 0.4.45

package/src/tools/credentials/account-registry.ts

@@ -1,144 +0,0 @@
-import {
-  createAccount,
-  getAccount,
-  listAccounts,
-  updateAccount,
-} from "../../memory/account-store.js";
-import { RiskLevel } from "../../permissions/types.js";
-import type { ToolDefinition } from "../../providers/types.js";
-import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
-
-class AccountManageTool implements Tool {
-  name = "account_manage";
-  description = "Create, list, get, or update account records";
-  category = "credentials";
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: "object",
-        properties: {
-          action: {
-            type: "string",
-            enum: ["create", "list", "get", "update"],
-            description: "CRUD operation",
-          },
-          id: {
-            type: "string",
-            description: "Account ID (for get/update)",
-          },
-          service: {
-            type: "string",
-            description: "Service name",
-          },
-          username: { type: "string" },
-          email: { type: "string" },
-          display_name: { type: "string" },
-          status: {
-            type: "string",
-            enum: ["active", "pending_verification", "suspended"],
-          },
-          credential_ref: {
-            type: "string",
-            description: "Service name linking to credential vault",
-          },
-          metadata: { type: "object" },
-          reason: {
-            type: "string",
-            description:
-              "Brief non-technical explanation of what you are doing and why, shown to the user as a status update. Use simple language a non-technical person would understand.",
-          },
-        },
-        required: ["action"],
-      },
-    };
-  }
-
-  async execute(
-    input: Record<string, unknown>,
-    _context: ToolContext,
-  ): Promise<ToolExecutionResult> {
-    const action = input.action as string;
-
-    switch (action) {
-      case "create": {
-        const service = input.service as string | undefined;
-        if (!service || typeof service !== "string") {
-          return {
-            content: "Error: service is required for create action",
-            isError: true,
-          };
-        }
-
-        const record = createAccount({
-          service,
-          username: input.username as string | undefined,
-          email: input.email as string | undefined,
-          displayName: input.display_name as string | undefined,
-          status: input.status as string | undefined,
-          credentialRef: input.credential_ref as string | undefined,
-          metadata: input.metadata as Record<string, unknown> | undefined,
-        });
-
-        return { content: JSON.stringify(record, null, 2), isError: false };
-      }
-
-      case "list": {
-        const records = listAccounts({
-          service: input.service as string | undefined,
-          status: input.status as string | undefined,
-        });
-        return { content: JSON.stringify(records, null, 2), isError: false };
-      }
-
-      case "get": {
-        const id = input.id as string | undefined;
-        if (!id || typeof id !== "string") {
-          return {
-            content: "Error: id is required for get action",
-            isError: true,
-          };
-        }
-
-        const record = getAccount(id);
-        if (!record) {
-          return { content: `Error: account not found: ${id}`, isError: true };
-        }
-        return { content: JSON.stringify(record, null, 2), isError: false };
-      }
-
-      case "update": {
-        const id = input.id as string | undefined;
-        if (!id || typeof id !== "string") {
-          return {
-            content: "Error: id is required for update action",
-            isError: true,
-          };
-        }
-
-        const updated = updateAccount(id, {
-          service: input.service as string | undefined,
-          username: input.username as string | undefined,
-          email: input.email as string | undefined,
-          displayName: input.display_name as string | undefined,
-          status: input.status as string | undefined,
-          credentialRef: input.credential_ref as string | undefined,
-          metadata: input.metadata as Record<string, unknown> | undefined,
-        });
-
-        if (!updated) {
-          return { content: `Error: account not found: ${id}`, isError: true };
-        }
-        return { content: JSON.stringify(updated, null, 2), isError: false };
-      }
-
-      default:
-        return { content: `Error: unknown action "${action}"`, isError: true };
-    }
-  }
-}
-
-export const accountManageTool = new AccountManageTool();

package/src/tools/filesystem/view-image.ts

@@ -1,244 +0,0 @@
-import { execFileSync } from "node:child_process";
-import { readFileSync, statSync, unlinkSync } from "node:fs";
-import { tmpdir } from "node:os";
-import { extname, join } from "node:path";
-
-import { RiskLevel } from "../../permissions/types.js";
-import type { ImageContent, ToolDefinition } from "../../providers/types.js";
-import { registerTool } from "../registry.js";
-import { sandboxPolicy } from "../shared/filesystem/path-policy.js";
-import type { Tool, ToolContext, ToolExecutionResult } from "../types.js";
-
-const SUPPORTED_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;
-  }
-}
-
-class ViewImageTool implements Tool {
-  name = "view_image";
-  description =
-    "Read an image file from the filesystem and return it for visual analysis. Supports JPEG, PNG, GIF, and WebP.";
-  category = "filesystem";
-  defaultRiskLevel = RiskLevel.Low;
-
-  getDefinition(): ToolDefinition {
-    return {
-      name: this.name,
-      description: this.description,
-      input_schema: {
-        type: "object",
-        properties: {
-          path: {
-            type: "string",
-            description:
-              "The path to the image file (absolute or relative to working directory)",
-          },
-          reason: {
-            type: "string",
-            description:
-              "Brief non-technical explanation of what you are viewing and why, shown to the user as a status update. Use simple language a non-technical person would understand.",
-          },
-        },
-        required: ["path"],
-      },
-    };
-  }
-
-  async execute(
-    input: Record<string, unknown>,
-    context: ToolContext,
-  ): Promise<ToolExecutionResult> {
-    const rawPath = input.path as string;
-    if (!rawPath || typeof rawPath !== "string") {
-      return {
-        content: "Error: path is required and must be a string",
-        isError: true,
-      };
-    }
-
-    const pathCheck = sandboxPolicy(rawPath, context.workingDir);
-    if (!pathCheck.ok) {
-      return { content: `Error: ${pathCheck.error}`, isError: true };
-    }
-    const resolved = pathCheck.resolved;
-
-    const ext = extname(resolved).toLowerCase();
-    if (!SUPPORTED_EXTENSIONS.has(ext)) {
-      const supported = [...SUPPORTED_EXTENSIONS].join(", ");
-      return {
-        content: `Error: unsupported image format "${ext}". Supported: ${supported}`,
-        isError: true,
-      };
-    }
-
-    let stat;
-    try {
-      stat = statSync(resolved);
-    } catch {
-      return { content: `Error: file not found: ${resolved}`, isError: true };
-    }
-
-    if (!stat.isFile()) {
-      return { content: `Error: ${resolved} 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(resolved);
-        if (tmpPath) {
-          buffer = readFileSync(tmpPath) as Buffer;
-          optimized = true;
-        } else {
-          buffer = readFileSync(resolved) as Buffer;
-        }
-      } else {
-        buffer = readFileSync(resolved) 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 ${resolved}. 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: ${resolved} (${buffer.length} bytes, ${detectedType})${sizeSuffix}`,
-      isError: false,
-      contentBlocks: [imageBlock],
-    };
-  }
-}
-
-registerTool(new ViewImageTool());

package/src/tools/reminder/reminder-store.ts

@@ -1,194 +0,0 @@
-import { and, asc, eq, lte } from "drizzle-orm";
-import { v4 as uuid } from "uuid";
-
-import { getDb, rawRun } from "../../memory/db.js";
-import { reminders } from "../../memory/schema.js";
-import { cast, createRowMapper, parseJson } from "../../util/row-mapper.js";
-
-export type RoutingIntent = "single_channel" | "multi_channel" | "all_channels";
-
-export interface RoutingHints {
-  [key: string]: unknown;
-}
-
-export interface ReminderRow {
-  id: string;
-  label: string;
-  message: string;
-  fireAt: number;
-  mode: "notify" | "execute";
-  status: "pending" | "firing" | "fired" | "cancelled";
-  firedAt: number | null;
-  conversationId: string | null;
-  routingIntent: RoutingIntent;
-  routingHints: RoutingHints;
-  createdAt: number;
-  updatedAt: number;
-}
-
-const parseRow = createRowMapper<typeof reminders.$inferSelect, ReminderRow>({
-  id: "id",
-  label: "label",
-  message: "message",
-  fireAt: "fireAt",
-  mode: { from: "mode", transform: cast<ReminderRow["mode"]>() },
-  status: { from: "status", transform: cast<ReminderRow["status"]>() },
-  firedAt: "firedAt",
-  conversationId: "conversationId",
-  routingIntent: { from: "routingIntent", transform: cast<RoutingIntent>() },
-  routingHints: {
-    from: "routingHintsJson",
-    transform: parseJson<RoutingHints>({}),
-  },
-  createdAt: "createdAt",
-  updatedAt: "updatedAt",
-});
-
-export function insertReminder(params: {
-  label: string;
-  message: string;
-  fireAt: number;
-  mode: "notify" | "execute";
-  routingIntent?: RoutingIntent;
-  routingHints?: RoutingHints;
-}): ReminderRow {
-  const db = getDb();
-  const id = uuid();
-  const now = Date.now();
-  const routingIntent = params.routingIntent ?? "all_channels";
-  const routingHints = params.routingHints ?? {};
-  const row = {
-    id,
-    label: params.label,
-    message: params.message,
-    fireAt: params.fireAt,
-    mode: params.mode,
-    status: "pending" as const,
-    firedAt: null,
-    conversationId: null,
-    routingIntent,
-    routingHintsJson: JSON.stringify(routingHints),
-    createdAt: now,
-    updatedAt: now,
-  };
-  db.insert(reminders).values(row).run();
-  return {
-    id,
-    label: params.label,
-    message: params.message,
-    fireAt: params.fireAt,
-    mode: params.mode,
-    status: "pending",
-    firedAt: null,
-    conversationId: null,
-    routingIntent,
-    routingHints,
-    createdAt: now,
-    updatedAt: now,
-  };
-}
-
-export function getReminder(id: string): ReminderRow | null {
-  const db = getDb();
-  const row = db.select().from(reminders).where(eq(reminders.id, id)).get();
-  if (!row) return null;
-  return parseRow(row);
-}
-
-export function listReminders(options?: {
-  pendingOnly?: boolean;
-}): ReminderRow[] {
-  const db = getDb();
-  const conditions = options?.pendingOnly
-    ? eq(reminders.status, "pending")
-    : undefined;
-  const rows = db
-    .select()
-    .from(reminders)
-    .where(conditions)
-    .orderBy(asc(reminders.fireAt))
-    .all();
-  return rows.map(parseRow);
-}
-
-export function cancelReminder(id: string): boolean {
-  const now = Date.now();
-  return (
-    rawRun(
-      "UPDATE reminders SET status = ?, updated_at = ? WHERE id = ? AND status = ?",
-      "cancelled",
-      now,
-      id,
-      "pending",
-    ) > 0
-  );
-}
-
-/**
- * Claim all pending reminders where fire_at <= now.
- * Transitions to 'firing' (not 'fired') so the reminder stays recoverable
- * if execution fails. Call completeReminder() after successful delivery
- * to move to the terminal 'fired' state.
- */
-export function claimDueReminders(now: number): ReminderRow[] {
-  const db = getDb();
-  const candidates = db
-    .select()
-    .from(reminders)
-    .where(and(eq(reminders.status, "pending"), lte(reminders.fireAt, now)))
-    .orderBy(asc(reminders.fireAt))
-    .all();
-
-  const claimed: ReminderRow[] = [];
-  for (const row of candidates) {
-    const changed = rawRun(
-      "UPDATE reminders SET status = ?, fired_at = ?, updated_at = ? WHERE id = ? AND status = ?",
-      "firing",
-      now,
-      now,
-      row.id,
-      "pending",
-    );
-
-    if (changed === 0) continue;
-
-    claimed.push(
-      parseRow({
-        ...row,
-        status: "firing",
-        firedAt: now,
-        updatedAt: now,
-      }),
-    );
-  }
-  return claimed;
-}
-
-/** Mark a claimed reminder as successfully delivered. */
-export function completeReminder(id: string): void {
-  const db = getDb();
-  db.update(reminders)
-    .set({ status: "fired", updatedAt: Date.now() })
-    .where(and(eq(reminders.id, id), eq(reminders.status, "firing")))
-    .run();
-}
-
-/** Revert a claimed reminder back to pending so it can be retried. */
-export function failReminder(id: string): void {
-  const db = getDb();
-  db.update(reminders)
-    .set({ status: "pending", firedAt: null, updatedAt: Date.now() })
-    .where(and(eq(reminders.id, id), eq(reminders.status, "firing")))
-    .run();
-}
-
-export function setReminderConversationId(
-  id: string,
-  conversationId: string,
-): void {
-  const db = getDb();
-  db.update(reminders)
-    .set({ conversationId, updatedAt: Date.now() })
-    .where(eq(reminders.id, id))
-    .run();
-}