@vellumai/assistant 0.4.52 → 0.4.54

package/src/memory/media-store.ts

@@ -5,19 +5,11 @@
  * Uses content-hash deduplication (same pattern as attachments-store.ts).
  */
 
-import { and, asc, desc, eq, gte, inArray } from "drizzle-orm";
+import { eq } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
 import { getDb } from "./db.js";
-import {
-  mediaAssets,
-  mediaEvents,
-  mediaKeyframes,
-  mediaTimelines,
-  mediaTrackingProfiles,
-  mediaVisionOutputs,
-  processingStages,
-} from "./schema.js";
+import { mediaAssets, mediaKeyframes, processingStages } from "./schema.js";
 
 // ---------------------------------------------------------------------------
 // Types
@@ -62,19 +54,8 @@ export interface ProcessingStage {
 // ---------------------------------------------------------------------------
 
 /**
- * Compute a content hash for deduplication. Uses SHA-256 hex encoding for
- * consistency with the streaming variant.
- */
-export function computeFileHash(data: Buffer | Uint8Array): string {
-  const hasher = new Bun.CryptoHasher("sha256");
-  hasher.update(data);
-  return hasher.digest("hex");
-}
-
-/**
- * Streaming variant of content hashing that avoids loading the entire file
- * into memory. Uses SHA-256 via Bun.CryptoHasher so multi-GB files won't OOM.
- * Produces the same hash format as `computeFileHash`.
+ * Streaming content hashing that avoids loading the entire file into memory.
+ * Uses SHA-256 via Bun.CryptoHasher so multi-GB files won't OOM.
  */
 export async function computeFileHashStreaming(
   filePath: string,
@@ -291,26 +272,6 @@ export interface MediaKeyframe {
   createdAt: number;
 }
 
-export function insertKeyframe(params: {
-  assetId: string;
-  timestamp: number;
-  filePath: string;
-  metadata?: Record<string, unknown>;
-}): MediaKeyframe {
-  const db = getDb();
-  const now = Date.now();
-  const record = {
-    id: uuid(),
-    assetId: params.assetId,
-    timestamp: params.timestamp,
-    filePath: params.filePath,
-    metadata: params.metadata ? JSON.stringify(params.metadata) : null,
-    createdAt: now,
-  };
-  db.insert(mediaKeyframes).values(record).run();
-  return { ...record, metadata: params.metadata ?? null };
-}
-
 export function insertKeyframesBatch(
   rows: Array<{
     assetId: string;
@@ -353,16 +314,6 @@ export function deleteKeyframesForAsset(assetId: string): void {
   db.delete(mediaKeyframes).where(eq(mediaKeyframes.assetId, assetId)).run();
 }
 
-export function getKeyframeById(id: string): MediaKeyframe | null {
-  const db = getDb();
-  const row = db
-    .select()
-    .from(mediaKeyframes)
-    .where(eq(mediaKeyframes.id, id))
-    .get();
-  return row ? parseKeyframeRow(row) : null;
-}
-
 function parseKeyframeRow(
   row: typeof mediaKeyframes.$inferSelect,
 ): MediaKeyframe {
@@ -383,485 +334,3 @@ function parseKeyframeRow(
     createdAt: row.createdAt,
   };
 }
-
-// ---------------------------------------------------------------------------
-// Vision output types & CRUD
-// ---------------------------------------------------------------------------
-
-export interface MediaVisionOutput {
-  id: string;
-  assetId: string;
-  keyframeId: string;
-  analysisType: string;
-  output: Record<string, unknown>;
-  confidence: number | null;
-  createdAt: number;
-}
-
-export function insertVisionOutput(params: {
-  assetId: string;
-  keyframeId: string;
-  analysisType: string;
-  output: Record<string, unknown>;
-  confidence?: number;
-}): MediaVisionOutput {
-  const db = getDb();
-  const now = Date.now();
-  const record = {
-    id: uuid(),
-    assetId: params.assetId,
-    keyframeId: params.keyframeId,
-    analysisType: params.analysisType,
-    output: JSON.stringify(params.output),
-    confidence: params.confidence ?? null,
-    createdAt: now,
-  };
-  db.insert(mediaVisionOutputs).values(record).run();
-  return { ...record, output: params.output };
-}
-
-export function insertVisionOutputsBatch(
-  rows: Array<{
-    assetId: string;
-    keyframeId: string;
-    analysisType: string;
-    output: Record<string, unknown>;
-    confidence?: number;
-  }>,
-): MediaVisionOutput[] {
-  const db = getDb();
-  const now = Date.now();
-  const records = rows.map((r) => ({
-    id: uuid(),
-    assetId: r.assetId,
-    keyframeId: r.keyframeId,
-    analysisType: r.analysisType,
-    output: JSON.stringify(r.output),
-    confidence: r.confidence ?? null,
-    createdAt: now,
-  }));
-  if (records.length > 0) {
-    db.insert(mediaVisionOutputs).values(records).run();
-  }
-  return records.map((rec, i) => ({
-    ...rec,
-    output: rows[i].output,
-  }));
-}
-
-export function getVisionOutputsForAsset(
-  assetId: string,
-  analysisType?: string,
-): MediaVisionOutput[] {
-  const db = getDb();
-  const conditions = [eq(mediaVisionOutputs.assetId, assetId)];
-  if (analysisType) {
-    conditions.push(eq(mediaVisionOutputs.analysisType, analysisType));
-  }
-  const rows = db
-    .select()
-    .from(mediaVisionOutputs)
-    .where(and(...conditions))
-    .all();
-  return rows.map(parseVisionOutputRow);
-}
-
-export function getVisionOutputsByKeyframeIds(
-  keyframeIds: string[],
-): MediaVisionOutput[] {
-  if (keyframeIds.length === 0) return [];
-  const db = getDb();
-  const rows = db
-    .select()
-    .from(mediaVisionOutputs)
-    .where(inArray(mediaVisionOutputs.keyframeId, keyframeIds))
-    .all();
-  return rows.map(parseVisionOutputRow);
-}
-
-function parseVisionOutputRow(
-  row: typeof mediaVisionOutputs.$inferSelect,
-): MediaVisionOutput {
-  let output: Record<string, unknown> = {};
-  try {
-    output = JSON.parse(row.output) as Record<string, unknown>;
-  } catch {
-    output = {};
-  }
-  return {
-    id: row.id,
-    assetId: row.assetId,
-    keyframeId: row.keyframeId,
-    analysisType: row.analysisType,
-    output,
-    confidence: row.confidence,
-    createdAt: row.createdAt,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Timeline types & CRUD
-// ---------------------------------------------------------------------------
-
-export interface MediaTimeline {
-  id: string;
-  assetId: string;
-  startTime: number;
-  endTime: number;
-  segmentType: string;
-  attributes: Record<string, unknown> | null;
-  confidence: number | null;
-  createdAt: number;
-}
-
-export function insertTimelineSegment(params: {
-  assetId: string;
-  startTime: number;
-  endTime: number;
-  segmentType: string;
-  attributes?: Record<string, unknown>;
-  confidence?: number;
-}): MediaTimeline {
-  const db = getDb();
-  const now = Date.now();
-  const record = {
-    id: uuid(),
-    assetId: params.assetId,
-    startTime: params.startTime,
-    endTime: params.endTime,
-    segmentType: params.segmentType,
-    attributes: params.attributes ? JSON.stringify(params.attributes) : null,
-    confidence: params.confidence ?? null,
-    createdAt: now,
-  };
-  db.insert(mediaTimelines).values(record).run();
-  return { ...record, attributes: params.attributes ?? null };
-}
-
-export function insertTimelineSegmentsBatch(
-  rows: Array<{
-    assetId: string;
-    startTime: number;
-    endTime: number;
-    segmentType: string;
-    attributes?: Record<string, unknown>;
-    confidence?: number;
-  }>,
-): MediaTimeline[] {
-  const db = getDb();
-  const now = Date.now();
-  const records = rows.map((r) => ({
-    id: uuid(),
-    assetId: r.assetId,
-    startTime: r.startTime,
-    endTime: r.endTime,
-    segmentType: r.segmentType,
-    attributes: r.attributes ? JSON.stringify(r.attributes) : null,
-    confidence: r.confidence ?? null,
-    createdAt: now,
-  }));
-  if (records.length > 0) {
-    db.insert(mediaTimelines).values(records).run();
-  }
-  return records.map((rec, i) => ({
-    ...rec,
-    attributes: rows[i].attributes ?? null,
-  }));
-}
-
-export function getTimelineForAsset(assetId: string): MediaTimeline[] {
-  const db = getDb();
-  const rows = db
-    .select()
-    .from(mediaTimelines)
-    .where(eq(mediaTimelines.assetId, assetId))
-    .all();
-  return rows.map(parseTimelineRow);
-}
-
-export function deleteTimelineForAsset(assetId: string): void {
-  const db = getDb();
-  db.delete(mediaTimelines).where(eq(mediaTimelines.assetId, assetId)).run();
-}
-
-function parseTimelineRow(
-  row: typeof mediaTimelines.$inferSelect,
-): MediaTimeline {
-  let attributes: Record<string, unknown> | null = null;
-  if (row.attributes) {
-    try {
-      attributes = JSON.parse(row.attributes) as Record<string, unknown>;
-    } catch {
-      attributes = null;
-    }
-  }
-  return {
-    id: row.id,
-    assetId: row.assetId,
-    startTime: row.startTime,
-    endTime: row.endTime,
-    segmentType: row.segmentType,
-    attributes,
-    confidence: row.confidence,
-    createdAt: row.createdAt,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Media event types & CRUD
-// ---------------------------------------------------------------------------
-
-export interface MediaEvent {
-  id: string;
-  assetId: string;
-  eventType: string;
-  startTime: number;
-  endTime: number;
-  confidence: number;
-  reasons: string[];
-  metadata: Record<string, unknown> | null;
-  createdAt: number;
-}
-
-export function insertEvent(params: {
-  assetId: string;
-  eventType: string;
-  startTime: number;
-  endTime: number;
-  confidence: number;
-  reasons: string[];
-  metadata?: Record<string, unknown>;
-}): MediaEvent {
-  const db = getDb();
-  const now = Date.now();
-  const record = {
-    id: uuid(),
-    assetId: params.assetId,
-    eventType: params.eventType,
-    startTime: params.startTime,
-    endTime: params.endTime,
-    confidence: params.confidence,
-    reasons: JSON.stringify(params.reasons),
-    metadata: params.metadata ? JSON.stringify(params.metadata) : null,
-    createdAt: now,
-  };
-  db.insert(mediaEvents).values(record).run();
-  return {
-    ...record,
-    reasons: params.reasons,
-    metadata: params.metadata ?? null,
-  };
-}
-
-export function insertEventsBatch(
-  rows: Array<{
-    assetId: string;
-    eventType: string;
-    startTime: number;
-    endTime: number;
-    confidence: number;
-    reasons: string[];
-    metadata?: Record<string, unknown>;
-  }>,
-): MediaEvent[] {
-  const db = getDb();
-  const now = Date.now();
-  const records = rows.map((r) => ({
-    id: uuid(),
-    assetId: r.assetId,
-    eventType: r.eventType,
-    startTime: r.startTime,
-    endTime: r.endTime,
-    confidence: r.confidence,
-    reasons: JSON.stringify(r.reasons),
-    metadata: r.metadata ? JSON.stringify(r.metadata) : null,
-    createdAt: now,
-  }));
-  if (records.length > 0) {
-    db.insert(mediaEvents).values(records).run();
-  }
-  return records.map((rec, i) => ({
-    ...rec,
-    reasons: rows[i].reasons,
-    metadata: rows[i].metadata ?? null,
-  }));
-}
-
-export function getEventsForAsset(
-  assetId: string,
-  filters?: {
-    eventType?: string;
-    minConfidence?: number;
-    limit?: number;
-    sortBy?: "confidence" | "startTime";
-  },
-): MediaEvent[] {
-  const db = getDb();
-  const conditions = [eq(mediaEvents.assetId, assetId)];
-  if (filters?.eventType) {
-    conditions.push(eq(mediaEvents.eventType, filters.eventType));
-  }
-  if (filters?.minConfidence !== undefined) {
-    conditions.push(gte(mediaEvents.confidence, filters.minConfidence));
-  }
-
-  let query = db
-    .select()
-    .from(mediaEvents)
-    .where(and(...conditions))
-    .$dynamic();
-
-  if (filters?.sortBy === "confidence") {
-    query = query.orderBy(desc(mediaEvents.confidence));
-  } else {
-    query = query.orderBy(asc(mediaEvents.startTime));
-  }
-
-  if (filters?.limit) {
-    query = query.limit(filters.limit);
-  }
-
-  const rows = query.all();
-  return rows.map(parseEventRow);
-}
-
-export function getEventById(id: string): MediaEvent | null {
-  const db = getDb();
-  const row = db.select().from(mediaEvents).where(eq(mediaEvents.id, id)).get();
-  return row ? parseEventRow(row) : null;
-}
-
-export function deleteEventsForAsset(assetId: string): void {
-  const db = getDb();
-  db.delete(mediaEvents).where(eq(mediaEvents.assetId, assetId)).run();
-}
-
-export function deleteEventsForAssetByType(
-  assetId: string,
-  eventType: string,
-): void {
-  const db = getDb();
-  db.delete(mediaEvents)
-    .where(
-      and(
-        eq(mediaEvents.assetId, assetId),
-        eq(mediaEvents.eventType, eventType),
-      ),
-    )
-    .run();
-}
-
-function parseEventRow(row: typeof mediaEvents.$inferSelect): MediaEvent {
-  let reasons: string[] = [];
-  try {
-    reasons = JSON.parse(row.reasons) as string[];
-  } catch {
-    reasons = [];
-  }
-  let metadata: Record<string, unknown> | null = null;
-  if (row.metadata) {
-    try {
-      metadata = JSON.parse(row.metadata) as Record<string, unknown>;
-    } catch {
-      metadata = null;
-    }
-  }
-  return {
-    id: row.id,
-    assetId: row.assetId,
-    eventType: row.eventType,
-    startTime: row.startTime,
-    endTime: row.endTime,
-    confidence: row.confidence,
-    reasons,
-    metadata,
-    createdAt: row.createdAt,
-  };
-}
-
-// ---------------------------------------------------------------------------
-// Tracking profile types & CRUD
-// ---------------------------------------------------------------------------
-
-export type CapabilityTier = "ready" | "beta" | "experimental";
-
-export interface CapabilityProfileEntry {
-  enabled: boolean;
-  tier: CapabilityTier;
-}
-
-export type CapabilityProfile = Record<string, CapabilityProfileEntry>;
-
-export interface TrackingProfile {
-  id: string;
-  assetId: string;
-  capabilities: CapabilityProfile;
-  createdAt: number;
-}
-
-/**
- * Upsert a tracking profile for a media asset. If a profile already exists
- * for the given assetId, it is replaced.
- */
-export function setTrackingProfile(
-  assetId: string,
-  capabilities: CapabilityProfile,
-): TrackingProfile {
-  const db = getDb();
-  const now = Date.now();
-
-  // Check for existing profile by assetId
-  const existing = db
-    .select()
-    .from(mediaTrackingProfiles)
-    .where(eq(mediaTrackingProfiles.assetId, assetId))
-    .get();
-
-  if (existing) {
-    db.update(mediaTrackingProfiles)
-      .set({ capabilities: JSON.stringify(capabilities), createdAt: now })
-      .where(eq(mediaTrackingProfiles.id, existing.id))
-      .run();
-    return { id: existing.id, assetId, capabilities, createdAt: now };
-  }
-
-  const id = uuid();
-  db.insert(mediaTrackingProfiles)
-    .values({
-      id,
-      assetId,
-      capabilities: JSON.stringify(capabilities),
-      createdAt: now,
-    })
-    .run();
-
-  return { id, assetId, capabilities, createdAt: now };
-}
-
-/**
- * Get the current tracking profile for a media asset, if one exists.
- */
-export function getTrackingProfile(assetId: string): TrackingProfile | null {
-  const db = getDb();
-  const row = db
-    .select()
-    .from(mediaTrackingProfiles)
-    .where(eq(mediaTrackingProfiles.assetId, assetId))
-    .get();
-
-  if (!row) return null;
-
-  let capabilities: CapabilityProfile = {};
-  try {
-    capabilities = JSON.parse(row.capabilities) as CapabilityProfile;
-  } catch {
-    capabilities = {};
-  }
-
-  return {
-    id: row.id,
-    assetId: row.assetId,
-    capabilities,
-    createdAt: row.createdAt,
-  };
-}

package/src/memory/migrations/032-guardian-delivery-conversation-index.ts

@@ -3,8 +3,8 @@ import type { DrizzleDb } from "../db-connection.js";
 /**
  * Add index on guardian_action_deliveries.destination_conversation_id.
  *
- * Several lookup paths (getPendingDeliveryByConversation,
- * getExpiredDeliveryByConversation, getFollowupDeliveryByConversation)
+ * Several lookup paths (getPendingDeliveriesByConversation,
+ * getExpiredDeliveriesByConversation, getFollowupDeliveriesByConversation)
  * filter deliveries by destination_conversation_id. Without an index
  * these degrade to full table scans as delivery history grows.
  */

package/src/memory/migrations/110-channel-guardian.ts

@@ -89,7 +89,6 @@ export function createChannelGuardianTables(database: DrizzleDb): void {
   );
 
   // Migration: add assistant_id column to scope approval requests by assistant.
-  // Existing rows default to 'self' for backward compatibility.
   try {
     database.run(
       /*sql*/ `ALTER TABLE channel_guardian_approval_requests ADD COLUMN assistant_id TEXT NOT NULL DEFAULT 'self'`,

package/src/memory/migrations/158-channel-interaction-columns.ts

@@ -0,0 +1,18 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+export function migrateChannelInteractionColumns(database: DrizzleDb): void {
+  try {
+    database.run(
+      /*sql*/ `ALTER TABLE contact_channels ADD COLUMN interaction_count INTEGER NOT NULL DEFAULT 0`,
+    );
+  } catch {
+    /* already exists */
+  }
+  try {
+    database.run(
+      /*sql*/ `ALTER TABLE contact_channels ADD COLUMN last_interaction INTEGER`,
+    );
+  } catch {
+    /* already exists */
+  }
+}

package/src/memory/migrations/159-drop-contact-interaction-columns.ts

@@ -0,0 +1,16 @@
+import type { DrizzleDb } from "../db-connection.js";
+
+export function migrateDropContactInteractionColumns(
+  database: DrizzleDb,
+): void {
+  try {
+    database.run(/*sql*/ `ALTER TABLE contacts DROP COLUMN interaction_count`);
+  } catch {
+    /* already dropped or doesn't exist */
+  }
+  try {
+    database.run(/*sql*/ `ALTER TABLE contacts DROP COLUMN last_interaction`);
+  } catch {
+    /* already dropped or doesn't exist */
+  }
+}

package/src/memory/migrations/160-drop-loopback-port-column.ts

@@ -0,0 +1,13 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateDropLoopbackPortColumn(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      /*sql*/ `ALTER TABLE oauth_providers DROP COLUMN loopback_port`,
+    );
+  } catch {
+    // Column already dropped or doesn't exist — nothing to do.
+  }
+}

package/src/memory/migrations/index.ts

@@ -99,6 +99,9 @@ export { migrateDropMemorySegmentFts } from "./154-drop-fts.js";
 export { migrateDropConflicts } from "./155-drop-conflicts.js";
 export { migrateCallSessionInviteMetadata } from "./156-call-session-invite-metadata.js";
 export { migrateInviteContactId } from "./157-invite-contact-id.js";
+export { migrateChannelInteractionColumns } from "./158-channel-interaction-columns.js";
+export { migrateDropContactInteractionColumns } from "./159-drop-contact-interaction-columns.js";
+export { migrateDropLoopbackPortColumn } from "./160-drop-loopback-port-column.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,