@vellumai/assistant 0.4.44 → 0.4.45

package/src/memory/message-content.ts

@@ -45,6 +45,17 @@ export function extractTextFromStoredMessageContent(raw: string): string {
             );
           }
           break;
+        case "server_tool_use": {
+          const query =
+            typeof block.input?.query === "string"
+              ? block.input.query
+              : block.name;
+          lines.push(`[web search: ${query}]`);
+          break;
+        }
+        case "web_search_tool_result":
+          lines.push("[web search results]");
+          break;
         default:
           lines.push("<unknown_content_block />");
       }
@@ -55,6 +66,61 @@ export function extractTextFromStoredMessageContent(raw: string): string {
   }
 }
 
+export function extractMediaBlocks(raw: string): Array<{
+  type: "image";
+  data: Buffer;
+  mimeType: string;
+  index: number;
+}> {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+    const results: Array<{
+      type: "image";
+      data: Buffer;
+      mimeType: string;
+      index: number;
+    }> = [];
+    for (let i = 0; i < parsed.length; i++) {
+      const block = parsed[i] as ContentBlock;
+      if (block.type === "image") {
+        results.push({
+          type: "image" as const,
+          data: Buffer.from(block.source.data, "base64"),
+          mimeType: block.source.media_type,
+          index: i,
+        });
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Lightweight variant of extractMediaBlocks that returns only type and index
+ * metadata without decoding base64 image data into Buffers.
+ */
+export function extractMediaBlockMeta(
+  raw: string,
+): Array<{ type: "image"; index: number }> {
+  try {
+    const parsed = JSON.parse(raw) as unknown;
+    if (!Array.isArray(parsed)) return [];
+    const results: Array<{ type: "image"; index: number }> = [];
+    for (let i = 0; i < parsed.length; i++) {
+      const block = parsed[i] as { type?: string };
+      if (block.type === "image") {
+        results.push({ type: "image" as const, index: i });
+      }
+    }
+    return results;
+  } catch {
+    return [];
+  }
+}
+
 function stableJson(value: unknown): string {
   try {
     return JSON.stringify(value);

package/src/memory/migrations/100-core-tables.ts

@@ -5,7 +5,7 @@ import type { DrizzleDb } from "../db-connection.js";
  * memory_items, memory_item_sources, memory_item_conflicts, memory_summaries,
  * memory_embeddings, memory_jobs, memory_checkpoints, attachments,
  * message_attachments, message_surfaces, channel_inbound_events,
- * message_runs, reminders, cron_jobs, cron_runs, accounts, documents,
+ * message_runs, cron_jobs, cron_runs, documents,
  * published_pages, shared_app_links, home_base_app_links.
  */
 export function createCoreTables(database: DrizzleDb): void {
@@ -228,21 +228,6 @@ export function createCoreTables(database: DrizzleDb): void {
     )
   `);
 
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS reminders (
-      id TEXT PRIMARY KEY,
-      label TEXT NOT NULL,
-      message TEXT NOT NULL,
-      fire_at INTEGER NOT NULL,
-      mode TEXT NOT NULL,
-      status TEXT NOT NULL,
-      fired_at INTEGER,
-      conversation_id TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    )
-  `);
-
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS cron_jobs (
       id TEXT PRIMARY KEY,
@@ -277,21 +262,6 @@ export function createCoreTables(database: DrizzleDb): void {
     )
   `);
 
-  database.run(/*sql*/ `
-    CREATE TABLE IF NOT EXISTS accounts (
-      id TEXT PRIMARY KEY,
-      service TEXT NOT NULL,
-      username TEXT,
-      email TEXT,
-      display_name TEXT,
-      status TEXT NOT NULL DEFAULT 'active',
-      credential_ref TEXT,
-      metadata_json TEXT,
-      created_at INTEGER NOT NULL,
-      updated_at INTEGER NOT NULL
-    )
-  `);
-
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS documents (
       surface_id TEXT PRIMARY KEY,

package/src/memory/migrations/104-core-indexes.ts

@@ -198,10 +198,6 @@ export function createCoreIndexes(database: DrizzleDb): void {
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_message_runs_conversation ON message_runs(conversation_id)`,
   );
 
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_reminders_status_fire_at ON reminders(status, fire_at)`,
-  );
-
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next_run ON cron_jobs(enabled, next_run_at)`,
   );
@@ -212,13 +208,6 @@ export function createCoreIndexes(database: DrizzleDb): void {
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_runs_job_id ON cron_runs(job_id)`,
   );
 
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_accounts_service ON accounts(service)`,
-  );
-  database.run(
-    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_accounts_status ON accounts(status)`,
-  );
-
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_llm_usage_events_created_at ON llm_usage_events(created_at)`,
   );

package/src/memory/migrations/145-drop-accounts-table.ts

@@ -0,0 +1,19 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Drop the unused legacy accounts table and its indexes.
+ *
+ * The daemon no longer exposes account_manage or reads from the backing
+ * account-store path, so retaining the table only leaves dead state around.
+ */
+export function migrateDropAccountsTable(database: DrizzleDb): void {
+  withCrashRecovery(database, "migration_drop_accounts_table_v1", () => {
+    const raw = getSqliteFrom(database);
+
+    raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_accounts_service`);
+    raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_accounts_status`);
+    raw.exec(/*sql*/ `DROP TABLE IF EXISTS accounts`);
+  });
+}

package/src/memory/migrations/146-schedule-oneshot-routing.ts

@@ -0,0 +1,94 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Extend cron_jobs table with one-shot and routing support.
+ *
+ * - Make `cron_expression` nullable (SQLite requires table rebuild for
+ *   nullability changes). One-shot schedules have NULL cron_expression.
+ * - Add `mode` column: 'notify' | 'execute'
+ * - Add `routing_intent` column: 'single_channel' | 'multi_channel' | 'all_channels'
+ * - Add `routing_hints_json` column: opaque JSON routing hints
+ * - Add `status` column: 'active' | 'firing' | 'fired' | 'cancelled'
+ * - Add composite index for one-shot claiming: (status, next_run_at)
+ */
+export function migrateScheduleOneShotRouting(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // Check if migration is already done by inspecting whether the status column exists
+  const tableInfo = raw
+    .query("PRAGMA table_info(cron_jobs)")
+    .all() as Array<{ name: string }>;
+  const hasStatusColumn = tableInfo.some((col) => col.name === "status");
+  if (hasStatusColumn) {
+    // Ensure all indexes exist even if the column migration already ran
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next_run ON cron_jobs(enabled, next_run_at)`,
+    );
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_jobs_syntax_enabled_next_run ON cron_jobs(schedule_syntax, enabled, next_run_at)`,
+    );
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_cron_jobs_status_next_run_at ON cron_jobs(status, next_run_at)`,
+    );
+    return;
+  }
+
+  raw.exec("PRAGMA foreign_keys = OFF");
+  try {
+    raw.exec(/*sql*/ `
+      BEGIN;
+
+      CREATE TABLE cron_jobs_new (
+        id TEXT PRIMARY KEY,
+        name TEXT NOT NULL,
+        enabled INTEGER NOT NULL DEFAULT 1,
+        cron_expression TEXT,
+        schedule_syntax TEXT NOT NULL DEFAULT 'cron',
+        timezone TEXT,
+        message TEXT NOT NULL,
+        next_run_at INTEGER NOT NULL,
+        last_run_at INTEGER,
+        last_status TEXT,
+        retry_count INTEGER NOT NULL DEFAULT 0,
+        created_by TEXT NOT NULL,
+        mode TEXT NOT NULL DEFAULT 'execute',
+        routing_intent TEXT NOT NULL DEFAULT 'all_channels',
+        routing_hints_json TEXT NOT NULL DEFAULT '{}',
+        status TEXT NOT NULL DEFAULT 'active',
+        created_at INTEGER NOT NULL,
+        updated_at INTEGER NOT NULL
+      );
+
+      INSERT INTO cron_jobs_new (
+        id, name, enabled, cron_expression, schedule_syntax, timezone,
+        message, next_run_at, last_run_at, last_status, retry_count,
+        created_by, mode, routing_intent, routing_hints_json, status,
+        created_at, updated_at
+      )
+      SELECT
+        id, name, enabled, cron_expression, schedule_syntax, timezone,
+        message, next_run_at, last_run_at, last_status, retry_count,
+        created_by, 'execute', 'all_channels', '{}', 'active',
+        created_at, updated_at
+      FROM cron_jobs;
+
+      DROP TABLE cron_jobs;
+      ALTER TABLE cron_jobs_new RENAME TO cron_jobs;
+
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_enabled_next_run ON cron_jobs(enabled, next_run_at);
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_syntax_enabled_next_run ON cron_jobs(schedule_syntax, enabled, next_run_at);
+      CREATE INDEX IF NOT EXISTS idx_cron_jobs_status_next_run_at ON cron_jobs(status, next_run_at);
+
+      COMMIT;
+    `);
+  } catch (e) {
+    try {
+      raw.exec("ROLLBACK");
+    } catch {
+      /* no active transaction */
+    }
+    throw e;
+  } finally {
+    raw.exec("PRAGMA foreign_keys = ON");
+  }
+}

package/src/memory/migrations/147-migrate-reminders-to-schedules.ts

@@ -0,0 +1,129 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Migrate all existing reminders into the cron_jobs (schedules) table as
+ * one-shot schedules.
+ *
+ * Field mapping:
+ *   reminder.label          → cron_jobs.name
+ *   reminder.message        → cron_jobs.message
+ *   reminder.fire_at        → cron_jobs.next_run_at
+ *   reminder.fired_at       → cron_jobs.last_run_at
+ *   reminder.mode           → cron_jobs.mode
+ *   reminder.routing_intent → cron_jobs.routing_intent
+ *   reminder.routing_hints_json → cron_jobs.routing_hints_json
+ *   reminder.created_at     → cron_jobs.created_at
+ *   reminder.updated_at     → cron_jobs.updated_at
+ *
+ * Status mapping:
+ *   pending   → active
+ *   firing    → firing
+ *   fired     → fired
+ *   cancelled → cancelled
+ *
+ * Enabled: pending → 1, all others → 0
+ *
+ * last_status: fired → 'ok', others → NULL
+ *
+ * One-shot schedules have NULL cron_expression. The reminders table is
+ * preserved for the subsequent cleanup PR.
+ */
+export function migrateRemindersToSchedules(database: DrizzleDb): void {
+  withCrashRecovery(
+    database,
+    "migration_reminders_to_schedules_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      // Guard: if the reminders table doesn't exist, nothing to migrate.
+      const hasReminders = raw
+        .query(
+          "SELECT name FROM sqlite_master WHERE type='table' AND name='reminders'",
+        )
+        .get();
+      if (!hasReminders) return;
+
+      // Read all reminders into memory. We use the reminder's original ID as
+      // the cron_jobs primary key so that INSERT OR IGNORE deduplicates
+      // correctly if the migration re-runs after a crash.
+      const reminders = raw.query("SELECT * FROM reminders").all() as Array<{
+        id: string;
+        label: string;
+        message: string;
+        fire_at: number;
+        mode: string;
+        status: string;
+        fired_at: number | null;
+        routing_intent: string;
+        routing_hints_json: string;
+        created_at: number;
+        updated_at: number;
+      }>;
+
+      if (reminders.length === 0) return;
+
+      const insert = raw.query(/*sql*/ `
+        INSERT OR IGNORE INTO cron_jobs (
+          id, name, enabled, cron_expression, schedule_syntax, timezone,
+          message, next_run_at, last_run_at, last_status, retry_count,
+          created_by, mode, routing_intent, routing_hints_json, status,
+          created_at, updated_at
+        ) VALUES (
+          ?, ?, ?, NULL, 'cron', NULL,
+          ?, ?, ?, ?, 0,
+          'agent', ?, ?, ?, ?,
+          ?, ?
+        )
+      `);
+
+      // Mark migrated pending reminders as fired so the legacy
+      // claimDueReminders path doesn't fire them a second time.
+      const markFired = raw.query(/*sql*/ `
+        UPDATE reminders SET status = 'fired', fired_at = ?
+        WHERE id = ? AND status = 'pending'
+      `);
+
+      try {
+        raw.exec("BEGIN");
+
+        for (const r of reminders) {
+          const statusMap: Record<string, string> = {
+            pending: "active",
+            firing: "firing",
+            fired: "fired",
+            cancelled: "cancelled",
+          };
+
+          insert.run(
+            r.id,
+            r.label,
+            r.status === "pending" ? 1 : 0,
+            // message, next_run_at, last_run_at, last_status
+            r.message,
+            r.fire_at,
+            r.fired_at,
+            r.status === "fired" ? "ok" : null,
+            // mode, routing_intent, routing_hints_json, status
+            r.mode,
+            r.routing_intent,
+            r.routing_hints_json,
+            statusMap[r.status] ?? "active",
+            // created_at, updated_at
+            r.created_at,
+            r.updated_at,
+          );
+
+          if (r.status === "pending") {
+            markFired.run(Date.now(), r.id);
+          }
+        }
+
+        raw.exec("COMMIT");
+      } catch (err) {
+        raw.exec("ROLLBACK");
+        throw err;
+      }
+    },
+  );
+}

package/src/memory/migrations/148-drop-reminders-table.ts

@@ -0,0 +1,18 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Drop the legacy reminders table and its index now that all data has been
+ * migrated into cron_jobs as one-shot schedules (migration 147).
+ */
+export function migrateDropRemindersTable(database: DrizzleDb): void {
+  withCrashRecovery(
+    database,
+    "migration_drop_reminders_table_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+      raw.run("DROP INDEX IF EXISTS idx_reminders_status_fire_at");
+      raw.run("DROP TABLE IF EXISTS reminders");
+    },
+  );
+}

package/src/memory/migrations/index.ts

@@ -86,6 +86,10 @@ export { migrateRenameVerificationTable } from "./141-rename-verification-table.
 export { migrateRenameVerificationSessionIdColumn } from "./142-rename-verification-session-id-column.js";
 export { migrateRenameGuardianVerificationValues } from "./143-rename-guardian-verification-values.js";
 export { migrateRenameVoiceToPhone } from "./144-rename-voice-to-phone.js";
+export { migrateDropAccountsTable } from "./145-drop-accounts-table.js";
+export { migrateScheduleOneShotRouting } from "./146-schedule-oneshot-routing.js";
+export { migrateRemindersToSchedules } from "./147-migrate-reminders-to-schedules.js";
+export { migrateDropRemindersTable } from "./148-drop-reminders-table.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/migrations/registry.ts

@@ -171,6 +171,25 @@ export const MIGRATION_REGISTRY: MigrationRegistryEntry[] = [
     description:
       'Rename stored "voice" channel values to "phone" across all tables with channel text columns',
   },
+  {
+    key: "migration_drop_accounts_table_v1",
+    version: 25,
+    description:
+      "Drop the unused legacy accounts table and its leftover indexes after account_manage removal",
+  },
+  {
+    key: "migration_reminders_to_schedules_v1",
+    version: 26,
+    description:
+      "Copy all existing reminders into cron_jobs as one-shot schedules with correct status and field mapping",
+  },
+  {
+    key: "migration_drop_reminders_table_v1",
+    version: 27,
+    dependsOn: ["migration_reminders_to_schedules_v1"],
+    description:
+      "Drop the legacy reminders table and its index after data migration to cron_jobs",
+  },
 ];
 
 export interface MigrationValidationResult {