@vellumai/assistant 0.4.41 → 0.4.43

package/src/memory/migrations/114-notifications.ts

@@ -2,7 +2,6 @@ import type { DrizzleDb } from "../db-connection.js";
 import { migrateNotificationTablesSchema } from "./019-notification-tables-schema-migration.js";
 import { migrateNotificationDeliveryPairingColumns } from "./027-notification-delivery-pairing-columns.js";
 import { migrateNotificationDeliveryClientAck } from "./028-notification-delivery-client-ack.js";
-import { tableHasColumn } from "./schema-introspection.js";
 
 /**
  * Notification system tables: preferences, events, decisions, and deliveries.
@@ -16,7 +15,6 @@ export function createNotificationTables(database: DrizzleDb): void {
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS notification_preferences (
       id TEXT PRIMARY KEY,
-      assistant_id TEXT NOT NULL,
       preference_text TEXT NOT NULL,
       applies_when_json TEXT NOT NULL DEFAULT '{}',
       priority INTEGER NOT NULL DEFAULT 0,
@@ -25,23 +23,13 @@ export function createNotificationTables(database: DrizzleDb): void {
     )
   `);
 
-  if (tableHasColumn(database, "notification_preferences", "assistant_id")) {
-    database.run(
-      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_preferences_assistant_id ON notification_preferences(assistant_id)`,
-    );
-    database.run(
-      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_preferences_assistant_priority ON notification_preferences(assistant_id, priority DESC)`,
-    );
-  } else {
-    database.run(
-      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_preferences_priority ON notification_preferences(priority DESC)`,
-    );
-  }
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_preferences_priority ON notification_preferences(priority DESC)`,
+  );
 
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS notification_events (
       id TEXT PRIMARY KEY,
-      assistant_id TEXT NOT NULL,
       source_event_name TEXT NOT NULL,
       source_channel TEXT NOT NULL,
       source_session_id TEXT NOT NULL,
@@ -53,21 +41,12 @@ export function createNotificationTables(database: DrizzleDb): void {
     )
   `);
 
-  if (tableHasColumn(database, "notification_events", "assistant_id")) {
-    database.run(
-      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_events_assistant_event_created ON notification_events(assistant_id, source_event_name, created_at)`,
-    );
-    database.run(
-      /*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_notification_events_dedupe ON notification_events(assistant_id, dedupe_key) WHERE dedupe_key IS NOT NULL`,
-    );
-  } else {
-    database.run(
-      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_events_event_created ON notification_events(source_event_name, created_at)`,
-    );
-    database.run(
-      /*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_notification_events_dedupe ON notification_events(dedupe_key) WHERE dedupe_key IS NOT NULL`,
-    );
-  }
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_events_event_created ON notification_events(source_event_name, created_at)`,
+  );
+  database.run(
+    /*sql*/ `CREATE UNIQUE INDEX IF NOT EXISTS idx_notification_events_dedupe ON notification_events(dedupe_key) WHERE dedupe_key IS NOT NULL`,
+  );
 
   database.run(/*sql*/ `
     CREATE TABLE IF NOT EXISTS notification_decisions (
@@ -92,7 +71,6 @@ export function createNotificationTables(database: DrizzleDb): void {
     CREATE TABLE IF NOT EXISTS notification_deliveries (
       id TEXT PRIMARY KEY,
       notification_decision_id TEXT NOT NULL REFERENCES notification_decisions(id) ON DELETE CASCADE,
-      assistant_id TEXT NOT NULL,
       channel TEXT NOT NULL,
       destination TEXT NOT NULL,
       status TEXT NOT NULL DEFAULT 'pending',
@@ -113,15 +91,9 @@ export function createNotificationTables(database: DrizzleDb): void {
   database.run(
     /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_deliveries_decision_id ON notification_deliveries(notification_decision_id)`,
   );
-  if (tableHasColumn(database, "notification_deliveries", "assistant_id")) {
-    database.run(
-      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_deliveries_assistant_status ON notification_deliveries(assistant_id, status)`,
-    );
-  } else {
-    database.run(
-      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_deliveries_status ON notification_deliveries(status)`,
-    );
-  }
+  database.run(
+    /*sql*/ `CREATE INDEX IF NOT EXISTS idx_notification_deliveries_status ON notification_deliveries(status)`,
+  );
 
   // Add conversation pairing audit columns (idempotent ALTER TABLE)
   migrateNotificationDeliveryPairingColumns(database);

package/src/memory/migrations/140-backfill-usage-cache-accounting.ts

@@ -0,0 +1,357 @@
+import { getConfig } from "../../config/loader.js";
+import type {
+  AnthropicCacheCreationTokenDetails,
+  PricingUsage,
+} from "../../usage/types.js";
+import { getLogger } from "../../util/logger.js";
+import { resolvePricingForUsageWithOverrides } from "../../util/pricing.js";
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+const log = getLogger("memory-db");
+
+const CHECKPOINT_KEY = "migration_backfill_usage_cache_accounting_v1";
+
+interface UsageEventRow {
+  id: string;
+  conversation_id: string | null;
+  created_at: number;
+  provider: string;
+  model: string;
+  input_tokens: number;
+  output_tokens: number;
+  cache_creation_input_tokens: number | null;
+  cache_read_input_tokens: number | null;
+}
+
+interface RequestLogRow {
+  id: string;
+  conversation_id: string;
+  response_payload: string;
+  created_at: number;
+}
+
+interface ReconstructedUsage extends PricingUsage {
+  totalInputTokens: number;
+}
+
+function asRecord(value: unknown): Record<string, unknown> | null {
+  if (typeof value !== "object" || value == null) return null;
+  return value as Record<string, unknown>;
+}
+
+function parseRequiredTokenCount(value: unknown): number | null {
+  if (typeof value !== "number" || !Number.isFinite(value)) return null;
+  if (value < 0) return null;
+  return value;
+}
+
+function parseOptionalTokenCount(value: unknown): number {
+  if (typeof value !== "number" || !Number.isFinite(value)) return 0;
+  return Math.max(value, 0);
+}
+
+function parseResponseUsage(
+  responsePayload: string,
+): ReconstructedUsage | null {
+  let parsed: unknown;
+  try {
+    parsed = JSON.parse(responsePayload);
+  } catch {
+    return null;
+  }
+
+  const payloads = Array.isArray(parsed) ? parsed : [parsed];
+  if (payloads.length === 0) return null;
+
+  let directInputTokens = 0;
+  let outputTokens = 0;
+  let cacheReadInputTokens = 0;
+  let ephemeral5mInputTokens = 0;
+  let ephemeral1hInputTokens = 0;
+
+  for (const payload of payloads) {
+    const response = asRecord(payload);
+    const usage = asRecord(response?.usage);
+    if (!usage) return null;
+
+    const inputTokens = parseRequiredTokenCount(usage.input_tokens);
+    const responseOutputTokens = parseRequiredTokenCount(usage.output_tokens);
+    if (inputTokens == null || responseOutputTokens == null) {
+      return null;
+    }
+
+    const cacheReadTokens = parseOptionalTokenCount(
+      usage.cache_read_input_tokens,
+    );
+    const cacheCreation = asRecord(usage.cache_creation);
+
+    directInputTokens += inputTokens;
+    outputTokens += responseOutputTokens;
+    cacheReadInputTokens += cacheReadTokens;
+    ephemeral5mInputTokens += parseOptionalTokenCount(
+      cacheCreation?.ephemeral_5m_input_tokens,
+    );
+    ephemeral1hInputTokens += parseOptionalTokenCount(
+      cacheCreation?.ephemeral_1h_input_tokens,
+    );
+  }
+
+  const cacheCreationInputTokens =
+    ephemeral5mInputTokens + ephemeral1hInputTokens;
+  const anthropicCacheCreation: AnthropicCacheCreationTokenDetails | null =
+    cacheCreationInputTokens > 0
+      ? {
+          ephemeral_5m_input_tokens: ephemeral5mInputTokens,
+          ephemeral_1h_input_tokens: ephemeral1hInputTokens,
+        }
+      : null;
+
+  return {
+    directInputTokens,
+    outputTokens,
+    cacheCreationInputTokens,
+    cacheReadInputTokens,
+    anthropicCacheCreation,
+    totalInputTokens:
+      directInputTokens + cacheCreationInputTokens + cacheReadInputTokens,
+  };
+}
+
+function buildRequestLogMap(
+  rows: RequestLogRow[],
+): Map<string, RequestLogRow[]> {
+  const requestLogsByConversation = new Map<string, RequestLogRow[]>();
+  for (const row of rows) {
+    const conversationRows =
+      requestLogsByConversation.get(row.conversation_id) ?? [];
+    conversationRows.push(row);
+    requestLogsByConversation.set(row.conversation_id, conversationRows);
+  }
+  return requestLogsByConversation;
+}
+
+export function migrateBackfillUsageCacheAccounting(database: DrizzleDb): void {
+  withCrashRecovery(database, CHECKPOINT_KEY, () => {
+    const raw = getSqliteFrom(database);
+
+    const usageEventsTableExists = raw
+      .query(
+        `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'llm_usage_events'`,
+      )
+      .get();
+    const requestLogsTableExists = raw
+      .query(
+        `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'llm_request_logs'`,
+      )
+      .get();
+    if (!usageEventsTableExists || !requestLogsTableExists) return;
+
+    const usageRows = raw
+      .query(
+        /*sql*/ `
+        SELECT
+          id,
+          conversation_id,
+          created_at,
+          provider,
+          model,
+          input_tokens,
+          output_tokens,
+          cache_creation_input_tokens,
+          cache_read_input_tokens
+        FROM llm_usage_events
+        ORDER BY conversation_id ASC, created_at ASC, id ASC
+        `,
+      )
+      .all() as UsageEventRow[];
+
+    const requestLogRows = raw
+      .query(
+        /*sql*/ `
+        SELECT
+          id,
+          conversation_id,
+          response_payload,
+          created_at
+        FROM llm_request_logs
+        ORDER BY conversation_id ASC, created_at ASC, id ASC
+        `,
+      )
+      .all() as RequestLogRow[];
+
+    const requestLogsByConversation = buildRequestLogMap(requestLogRows);
+    const requestOffsets = new Map<string, number>();
+    const previousUsageEventCreatedAt = new Map<string, number>();
+    const pricingOverrides = getConfig().pricingOverrides;
+
+    let scannedAnthropicRows = 0;
+    let updatedRows = 0;
+    let skippedNoConversation = 0;
+    let skippedNoLogs = 0;
+    let ignoredUnusableLogs = 0;
+    let skippedInconsistentRows = 0;
+
+    const updateRow = raw.prepare(/*sql*/ `
+      UPDATE llm_usage_events
+      SET
+        input_tokens = ?,
+        output_tokens = ?,
+        cache_creation_input_tokens = ?,
+        cache_read_input_tokens = ?,
+        estimated_cost_usd = ?,
+        pricing_status = ?
+      WHERE id = ?
+      `);
+
+    try {
+      raw.exec("BEGIN");
+
+      for (const usageRow of usageRows) {
+        const conversationId = usageRow.conversation_id;
+        if (conversationId == null) {
+          if (usageRow.provider === "anthropic") {
+            scannedAnthropicRows += 1;
+            skippedNoConversation += 1;
+          }
+          continue;
+        }
+
+        const previousCreatedAt =
+          previousUsageEventCreatedAt.get(conversationId) ?? null;
+        const conversationRequestLogs =
+          requestLogsByConversation.get(conversationId) ?? [];
+        let requestOffset = requestOffsets.get(conversationId) ?? 0;
+        const windowLogs: RequestLogRow[] = [];
+
+        while (
+          requestOffset < conversationRequestLogs.length &&
+          conversationRequestLogs[requestOffset]!.created_at <=
+            usageRow.created_at
+        ) {
+          const requestLog = conversationRequestLogs[requestOffset]!;
+          if (
+            previousCreatedAt == null ||
+            requestLog.created_at > previousCreatedAt
+          ) {
+            windowLogs.push(requestLog);
+          }
+          requestOffset += 1;
+        }
+
+        requestOffsets.set(conversationId, requestOffset);
+        previousUsageEventCreatedAt.set(conversationId, usageRow.created_at);
+
+        if (usageRow.provider !== "anthropic") continue;
+
+        scannedAnthropicRows += 1;
+        if (windowLogs.length === 0) {
+          skippedNoLogs += 1;
+          continue;
+        }
+
+        let directInputTokens = 0;
+        let outputTokens = 0;
+        let cacheReadInputTokens = 0;
+        let cacheCreationInputTokens = 0;
+        let cacheCreation5mInputTokens = 0;
+        let cacheCreation1hInputTokens = 0;
+        let usableLogCount = 0;
+
+        for (const requestLog of windowLogs) {
+          const reconstructedUsage = parseResponseUsage(
+            requestLog.response_payload,
+          );
+          if (!reconstructedUsage) {
+            ignoredUnusableLogs += 1;
+            continue;
+          }
+          usableLogCount += 1;
+          directInputTokens += reconstructedUsage.directInputTokens;
+          outputTokens += reconstructedUsage.outputTokens;
+          cacheReadInputTokens += reconstructedUsage.cacheReadInputTokens;
+          cacheCreationInputTokens +=
+            reconstructedUsage.cacheCreationInputTokens;
+          cacheCreation5mInputTokens +=
+            reconstructedUsage.anthropicCacheCreation
+              ?.ephemeral_5m_input_tokens ?? 0;
+          cacheCreation1hInputTokens +=
+            reconstructedUsage.anthropicCacheCreation
+              ?.ephemeral_1h_input_tokens ?? 0;
+        }
+
+        if (usableLogCount === 0) {
+          skippedNoLogs += 1;
+          continue;
+        }
+
+        const totalInputTokens =
+          directInputTokens + cacheCreationInputTokens + cacheReadInputTokens;
+        const existingTotalInputTokens =
+          Math.max(usageRow.input_tokens, 0) +
+          Math.max(usageRow.cache_creation_input_tokens ?? 0, 0) +
+          Math.max(usageRow.cache_read_input_tokens ?? 0, 0);
+
+        // This lets the migration safely rewrite both flattened historical rows
+        // and already-correct rows, while skipping mismatched request-log windows.
+        if (
+          totalInputTokens < 0 ||
+          directInputTokens < 0 ||
+          totalInputTokens !== existingTotalInputTokens ||
+          outputTokens !== Math.max(usageRow.output_tokens, 0)
+        ) {
+          skippedInconsistentRows += 1;
+          continue;
+        }
+
+        const pricingUsage: PricingUsage = {
+          directInputTokens,
+          outputTokens,
+          cacheCreationInputTokens,
+          cacheReadInputTokens,
+          anthropicCacheCreation:
+            cacheCreationInputTokens > 0
+              ? {
+                  ephemeral_5m_input_tokens: cacheCreation5mInputTokens,
+                  ephemeral_1h_input_tokens: cacheCreation1hInputTokens,
+                }
+              : null,
+        };
+        const pricing = resolvePricingForUsageWithOverrides(
+          usageRow.provider,
+          usageRow.model,
+          pricingUsage,
+          pricingOverrides,
+        );
+
+        updateRow.run(
+          directInputTokens,
+          outputTokens,
+          cacheCreationInputTokens,
+          cacheReadInputTokens,
+          pricing.estimatedCostUsd,
+          pricing.pricingStatus,
+          usageRow.id,
+        );
+        updatedRows += 1;
+      }
+
+      raw.exec("COMMIT");
+    } catch (err) {
+      raw.exec("ROLLBACK");
+      throw err;
+    }
+
+    log.info(
+      {
+        scannedAnthropicRows,
+        updatedRows,
+        skippedNoConversation,
+        skippedNoLogs,
+        ignoredUnusableLogs,
+        skippedInconsistentRows,
+      },
+      "Backfilled historical Anthropic usage rows from request-log accounting",
+    );
+  });
+}

package/src/memory/migrations/141-rename-verification-table.ts

@@ -0,0 +1,55 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * One-shot migration: rename channel_guardian_verification_challenges →
+ * channel_verification_sessions, including all indexes that reference the
+ * old table name.
+ */
+export function migrateRenameVerificationTable(database: DrizzleDb): void {
+  withCrashRecovery(database, "migration_rename_verification_table_v1", () => {
+    const raw = getSqliteFrom(database);
+
+    // Check the old table exists before attempting anything
+    const oldTableExists = raw
+      .query(
+        `SELECT 1 FROM sqlite_master WHERE type = 'table' AND name = 'channel_guardian_verification_challenges'`,
+      )
+      .get();
+    if (!oldTableExists) return;
+
+    // Rename the physical table
+    raw.exec(
+      /*sql*/ `ALTER TABLE channel_guardian_verification_challenges RENAME TO channel_verification_sessions`,
+    );
+
+    // Drop and recreate indexes that referenced the old table name.
+    // SQLite automatically updates index table references on RENAME, but the
+    // index names still reference the old naming convention — drop and recreate
+    // with consistent names pointing at the new table.
+
+    raw.exec(
+      /*sql*/ `DROP INDEX IF EXISTS idx_channel_guardian_challenges_lookup`,
+    );
+    raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_guardian_sessions_active`);
+    raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_guardian_sessions_identity`);
+    raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_guardian_sessions_destination`);
+    raw.exec(/*sql*/ `DROP INDEX IF EXISTS idx_guardian_sessions_bootstrap`);
+
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_verification_sessions_lookup ON channel_verification_sessions(channel, challenge_hash, status)`,
+    );
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_verification_sessions_active ON channel_verification_sessions(channel, status)`,
+    );
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_verification_sessions_identity ON channel_verification_sessions(channel, expected_external_user_id, expected_chat_id, status)`,
+    );
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_verification_sessions_destination ON channel_verification_sessions(channel, destination_address)`,
+    );
+    raw.exec(
+      /*sql*/ `CREATE INDEX IF NOT EXISTS idx_verification_sessions_bootstrap ON channel_verification_sessions(channel, bootstrap_token_hash, status)`,
+    );
+  });
+}

package/src/memory/migrations/142-rename-verification-session-id-column.ts

@@ -0,0 +1,32 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * One-shot migration: rename the guardian_verification_session_id column
+ * in call_sessions to verification_session_id, dropping the "guardian_"
+ * prefix to align with the broader verification vocabulary.
+ */
+export function migrateRenameVerificationSessionIdColumn(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(
+    database,
+    "migration_rename_verification_session_id_column_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      // Check the old column exists before attempting the rename
+      const columns = raw
+        .query(`PRAGMA table_info(call_sessions)`)
+        .all() as Array<{ name: string }>;
+      const hasOldColumn = columns.some(
+        (c) => c.name === "guardian_verification_session_id",
+      );
+      if (!hasOldColumn) return;
+
+      raw.exec(
+        /*sql*/ `ALTER TABLE call_sessions RENAME COLUMN guardian_verification_session_id TO verification_session_id`,
+      );
+    },
+  );
+}

package/src/memory/migrations/143-rename-guardian-verification-values.ts

@@ -0,0 +1,48 @@
+import { type DrizzleDb, getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * One-shot migration: rename persisted `guardian_verification` and
+ * `guardian_voice_verification_*` / `outbound_guardian_voice_verification_*`
+ * values in the call_sessions and call_events tables to drop the "guardian_"
+ * prefix, aligning with the broader verification vocabulary.
+ *
+ * - call_sessions.call_mode: "guardian_verification" -> "verification"
+ * - call_events.event_type: six guardian_voice_verification_* values renamed
+ */
+export function migrateRenameGuardianVerificationValues(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(
+    database,
+    "migration_rename_guardian_verification_values_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+
+      // Rename call_mode values
+      raw.exec(
+        /*sql*/ `UPDATE call_sessions SET call_mode = 'verification' WHERE call_mode = 'guardian_verification'`,
+      );
+
+      // Rename event_type values
+      raw.exec(
+        /*sql*/ `UPDATE call_events SET event_type = 'voice_verification_started' WHERE event_type = 'guardian_voice_verification_started'`,
+      );
+      raw.exec(
+        /*sql*/ `UPDATE call_events SET event_type = 'voice_verification_succeeded' WHERE event_type = 'guardian_voice_verification_succeeded'`,
+      );
+      raw.exec(
+        /*sql*/ `UPDATE call_events SET event_type = 'voice_verification_failed' WHERE event_type = 'guardian_voice_verification_failed'`,
+      );
+      raw.exec(
+        /*sql*/ `UPDATE call_events SET event_type = 'outbound_voice_verification_started' WHERE event_type = 'outbound_guardian_voice_verification_started'`,
+      );
+      raw.exec(
+        /*sql*/ `UPDATE call_events SET event_type = 'outbound_voice_verification_succeeded' WHERE event_type = 'outbound_guardian_voice_verification_succeeded'`,
+      );
+      raw.exec(
+        /*sql*/ `UPDATE call_events SET event_type = 'outbound_voice_verification_failed' WHERE event_type = 'outbound_guardian_voice_verification_failed'`,
+      );
+    },
+  );
+}