@vellumai/assistant 0.5.1 → 0.5.3

package/src/memory/job-handlers/embedding.ts

@@ -11,7 +11,10 @@ import type { MemoryJob } from "../jobs-store.js";
 import { extractMediaBlocks } from "../message-content.js";
 import {
   mediaAssets,
+  memoryChunks,
+  memoryEpisodes,
   memoryItems,
+  memoryObservations,
   memorySegments,
   memorySummaries,
   messages,
@@ -34,6 +37,7 @@ export async function embedSegmentJob(
     conversation_id: segment.conversationId,
     message_id: segment.messageId,
     created_at: segment.createdAt,
+    memory_scope_id: segment.scopeId,
   });
 }
 
@@ -58,6 +62,7 @@ export async function embedItemJob(
     confidence: item.confidence,
     created_at: item.firstSeenAt,
     last_seen_at: item.lastSeenAt,
+    memory_scope_id: item.scopeId,
   });
 }
 
@@ -83,10 +88,31 @@ export async function embedSummaryJob(
       kind: summary.scope,
       created_at: summary.startAt,
       last_seen_at: summary.endAt,
+      memory_scope_id: summary.scopeId,
     },
   );
 }
 
+export async function embedChunkJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): Promise<void> {
+  const chunkId = asString(job.payload.chunkId);
+  if (!chunkId) return;
+  const db = getDb();
+  const chunk = db
+    .select()
+    .from(memoryChunks)
+    .where(eq(memoryChunks.id, chunkId))
+    .get();
+  if (!chunk) return;
+  await embedAndUpsert(config, "chunk", chunk.id, chunk.content, {
+    observation_id: chunk.observationId,
+    created_at: chunk.createdAt,
+    memory_scope_id: chunk.scopeId,
+  });
+}
+
 export async function embedMediaJob(
   job: MemoryJob,
   config: AssistantConfig,
@@ -116,6 +142,41 @@ export async function embedMediaJob(
     created_at: asset.createdAt,
     kind: asset.mediaType,
     subject: asset.title,
+    memory_scope_id: "default",
+  });
+}
+
+export async function embedObservationJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): Promise<void> {
+  const observationId = asString(job.payload.observationId);
+  const chunkId = asString(job.payload.chunkId);
+  if (!observationId || !chunkId) return;
+
+  const db = getDb();
+  const observation = db
+    .select()
+    .from(memoryObservations)
+    .where(eq(memoryObservations.id, observationId))
+    .get();
+  if (!observation) return;
+
+  const chunk = db
+    .select()
+    .from(memoryChunks)
+    .where(eq(memoryChunks.id, chunkId))
+    .get();
+  if (!chunk) return;
+
+  await embedAndUpsert(config, "observation", chunk.id, chunk.content, {
+    observation_id: observationId,
+    conversation_id: observation.conversationId,
+    role: observation.role,
+    modality: observation.modality,
+    source: observation.source,
+    created_at: observation.createdAt,
+    memory_scope_id: observation.scopeId,
   });
 }
 
@@ -155,3 +216,25 @@ export async function embedAttachmentJob(
     memory_scope_id: memoryScopeId,
   });
 }
+
+export async function embedEpisodeJob(
+  job: MemoryJob,
+  config: AssistantConfig,
+): Promise<void> {
+  const episodeId = asString(job.payload.episodeId);
+  if (!episodeId) return;
+  const db = getDb();
+  const episode = db
+    .select()
+    .from(memoryEpisodes)
+    .where(eq(memoryEpisodes.id, episodeId))
+    .get();
+  if (!episode) return;
+  const text = `[episode] ${episode.title}: ${episode.summary}`;
+  await embedAndUpsert(config, "episode", episode.id, text, {
+    conversation_id: episode.conversationId,
+    created_at: episode.startAt,
+    last_seen_at: episode.endAt,
+    memory_scope_id: episode.scopeId,
+  });
+}

package/src/memory/job-utils.ts

@@ -142,7 +142,7 @@ export function truncate(text: string, max: number): string {
 
 export async function embedAndUpsert(
   config: AssistantConfig,
-  targetType: "segment" | "item" | "summary" | "media",
+  targetType: "segment" | "item" | "summary" | "observation" | "chunk" | "episode" | "media",
   targetId: string,
   input: EmbeddingInput,
   extraPayload?: Record<string, unknown>,

package/src/memory/jobs-store.ts

@@ -12,6 +12,9 @@ export type MemoryJobType =
   | "embed_segment"
   | "embed_item"
   | "embed_summary"
+  | "embed_chunk"
+  | "embed_episode"
+  | "embed_observation"
   | "extract_items"
   | "extract_entities"
   | "cleanup_stale_superseded_items"
@@ -34,6 +37,9 @@ const EMBED_JOB_TYPES: MemoryJobType[] = [
   "embed_segment",
   "embed_item",
   "embed_summary",
+  "embed_chunk",
+  "embed_episode",
+  "embed_observation",
   "embed_media",
   "embed_attachment",
 ];

package/src/memory/jobs-worker.ts

@@ -11,8 +11,11 @@ import { generateConversationStartersJob } from "./job-handlers/conversation-sta
 // ── Per-job-type handlers ──────────────────────────────────────────
 import {
   embedAttachmentJob,
+  embedChunkJob,
+  embedEpisodeJob,
   embedItemJob,
   embedMediaJob,
+  embedObservationJob,
   embedSegmentJob,
   embedSummaryJob,
 } from "./job-handlers/embedding.js";
@@ -267,6 +270,15 @@ async function processJob(
     case "embed_summary":
       await embedSummaryJob(job, config);
       return;
+    case "embed_chunk":
+      await embedChunkJob(job, config);
+      return;
+    case "embed_episode":
+      await embedEpisodeJob(job, config);
+      return;
+    case "embed_observation":
+      await embedObservationJob(job, config);
+      return;
     case "extract_items":
       await extractItemsJob(job);
       return;

package/src/memory/llm-request-log-store.ts

@@ -1,6 +1,11 @@
-import { and, eq, gte, lte } from "drizzle-orm";
+import { and, eq, gte, inArray, isNull, lte } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import {
+  getAssistantMessageIdsInTurn,
+  getMessageById,
+  messageMetadataSchema,
+} from "./conversation-crud.js";
 import { getDb } from "./db.js";
 import { llmRequestLogs } from "./schema.js";
 
@@ -8,12 +13,16 @@ export function recordRequestLog(
   conversationId: string,
   requestPayload: string,
   responsePayload: string,
+  messageId?: string,
+  provider?: string,
 ): void {
   const db = getDb();
   db.insert(llmRequestLogs)
     .values({
       id: uuid(),
       conversationId,
+      messageId: messageId ?? null,
+      provider: provider ?? null,
       requestPayload,
       responsePayload,
       createdAt: Date.now(),
@@ -46,3 +55,93 @@ export function queryRequestLogs(
     .orderBy(llmRequestLogs.createdAt)
     .all();
 }
+
+export function backfillMessageIdOnLogs(
+  conversationId: string,
+  messageId: string,
+): void {
+  const db = getDb();
+  db.update(llmRequestLogs)
+    .set({ messageId })
+    .where(
+      and(
+        eq(llmRequestLogs.conversationId, conversationId),
+        isNull(llmRequestLogs.messageId),
+      ),
+    )
+    .run();
+}
+
+/**
+ * Internal helper: query `llm_request_logs` for rows matching any of the
+ * given message IDs, ordered by `createdAt ASC`. Uses the existing
+ * `idx_llm_request_logs_message_id` index via `inArray`.
+ */
+function selectLogsByMessageIds(messageIds: string[]): Array<{
+  id: string;
+  conversationId: string;
+  messageId: string | null;
+  provider: string | null;
+  requestPayload: string;
+  responsePayload: string;
+  createdAt: number;
+}> {
+  if (messageIds.length === 0) return [];
+  const db = getDb();
+  return db
+    .select({
+      id: llmRequestLogs.id,
+      conversationId: llmRequestLogs.conversationId,
+      messageId: llmRequestLogs.messageId,
+      provider: llmRequestLogs.provider,
+      requestPayload: llmRequestLogs.requestPayload,
+      responsePayload: llmRequestLogs.responsePayload,
+      createdAt: llmRequestLogs.createdAt,
+    })
+    .from(llmRequestLogs)
+    .where(inArray(llmRequestLogs.messageId, messageIds))
+    .orderBy(llmRequestLogs.createdAt)
+    .all();
+}
+
+export function getRequestLogsByMessageId(messageId: string): Array<{
+  id: string;
+  conversationId: string;
+  messageId: string | null;
+  provider: string | null;
+  requestPayload: string;
+  responsePayload: string;
+  createdAt: number;
+}> {
+  // Resolve all assistant message IDs in the same turn so the inspector
+  // shows every LLM call from the entire agent turn, not just the queried message.
+  const turnMessageIds = getAssistantMessageIdsInTurn(messageId);
+  const turnLogs = selectLogsByMessageIds(turnMessageIds);
+  if (turnLogs.length > 0) {
+    return turnLogs;
+  }
+
+  // Fork-source fallback: if no logs found for the turn, check whether
+  // the queried message was forked from a source and resolve that source's turn.
+  const message = getMessageById(messageId);
+  if (!message?.metadata) {
+    return [];
+  }
+
+  try {
+    const parsed = messageMetadataSchema.safeParse(
+      JSON.parse(message.metadata),
+    );
+    const sourceMessageId =
+      parsed.success && typeof parsed.data.forkSourceMessageId === "string"
+        ? parsed.data.forkSourceMessageId
+        : null;
+    if (!sourceMessageId || sourceMessageId === messageId) {
+      return [];
+    }
+    const sourceTurnIds = getAssistantMessageIdsInTurn(sourceMessageId);
+    return selectLogsByMessageIds(sourceTurnIds);
+  } catch {
+    return [];
+  }
+}

package/src/memory/migrations/102-alter-table-columns.ts

@@ -261,6 +261,11 @@ export function addCoreColumns(database: DrizzleDb): void {
   } catch {
     /* already exists */
   }
+  try {
+    database.run(/*sql*/ `ALTER TABLE attachments ADD COLUMN source_path TEXT`);
+  } catch {
+    /* already exists */
+  }
 
   // cron_jobs
   try {

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

@@ -15,9 +15,9 @@ 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 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

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

@@ -30,40 +30,37 @@ import { withCrashRecovery } from "./validate-migration-state.js";
  * preserved for the subsequent cleanup PR.
  */
 export function migrateRemindersToSchedules(database: DrizzleDb): void {
-  withCrashRecovery(
-    database,
-    "migration_reminders_to_schedules_v1",
-    () => {
-      const raw = getSqliteFrom(database);
+  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;
+    // 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;
-      }>;
+    // 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;
+    if (reminders.length === 0) return;
 
-      const insert = raw.query(/*sql*/ `
+    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,
@@ -77,53 +74,52 @@ export function migrateRemindersToSchedules(database: DrizzleDb): void {
         )
       `);
 
-      // Mark migrated pending reminders as fired so the legacy
-      // claimDueReminders path doesn't fire them a second time.
-      const markFired = raw.query(/*sql*/ `
+    // 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");
+    try {
+      raw.exec("BEGIN");
 
-        for (const r of reminders) {
-          const statusMap: Record<string, string> = {
-            pending: "active",
-            firing: "firing",
-            fired: "fired",
-            cancelled: "cancelled",
-          };
+      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,
-          );
+        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);
-          }
+        if (r.status === "pending") {
+          markFired.run(Date.now(), r.id);
         }
-
-        raw.exec("COMMIT");
-      } catch (err) {
-        raw.exec("ROLLBACK");
-        throw err;
       }
-    },
-  );
+
+      raw.exec("COMMIT");
+    } catch (err) {
+      raw.exec("ROLLBACK");
+      throw err;
+    }
+  });
 }

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

@@ -6,13 +6,9 @@ import { withCrashRecovery } from "./validate-migration-state.js";
  * 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");
-    },
-  );
+  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/160-drop-loopback-port-column.ts

@@ -4,9 +4,7 @@ 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`,
-    );
+    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/174-rename-thread-starters-table.ts

@@ -40,13 +40,6 @@ export function migrateRenameThreadStartersTable(database: DrizzleDb): void {
       raw.exec(
         /*sql*/ `CREATE INDEX IF NOT EXISTS idx_conversation_starters_card_type ON conversation_starters(card_type, scope_id)`,
       );
-
-      // Migrate checkpoint keys from old thread_starters: prefix to
-      // conversation_starters: so existing checkpoint data is found by
-      // the renamed code paths and unnecessary re-generation is avoided.
-      raw.exec(
-        /*sql*/ `UPDATE memory_checkpoints SET key = replace(key, 'thread_starters:', 'conversation_starters:') WHERE key LIKE 'thread_starters:%'`,
-      );
     },
   );
 }

package/src/memory/migrations/178-oauth-providers-managed-service-config-key.ts

@@ -0,0 +1,15 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateOAuthProvidersManagedServiceConfigKey(
+  database: DrizzleDb,
+): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(
+      /*sql*/ `ALTER TABLE oauth_providers ADD COLUMN managed_service_config_key TEXT`,
+    );
+  } catch {
+    // Column already exists — nothing to do.
+  }
+}

package/src/memory/migrations/179-llm-request-log-message-id.ts

@@ -0,0 +1,16 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateLlmRequestLogMessageId(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  try {
+    raw.exec(/*sql*/ `ALTER TABLE llm_request_logs ADD COLUMN message_id TEXT`);
+  } catch {
+    // Column already exists — nothing to do.
+  }
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_llm_request_logs_message_id
+    ON llm_request_logs(message_id)
+  `);
+}

package/src/memory/migrations/180-backfill-inline-attachments-to-disk.ts

@@ -0,0 +1,66 @@
+import { writeAttachmentToDisk } from "../attachments-store.js";
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+import { withCrashRecovery } from "./validate-migration-state.js";
+
+/**
+ * Backfill existing inline (base64-in-DB) attachments to disk.
+ *
+ * Finds attachment rows that have non-empty data_base64 but no file_path,
+ * writes each one to disk, and updates the row to store the file path
+ * while clearing the inline data.
+ *
+ * Processes in batches of 50 to avoid holding large amounts of base64 data
+ * in memory at once.
+ */
+export function migrateBackfillInlineAttachmentsToDisk(
+  database: DrizzleDb,
+): void {
+  withCrashRecovery(
+    database,
+    "migration_backfill_inline_attachments_v1",
+    () => {
+      const raw = getSqliteFrom(database);
+      const BATCH_SIZE = 50;
+      let totalMigrated = 0;
+
+      for (;;) {
+        const rows = raw
+          .query(
+            `SELECT id, original_filename, data_base64 FROM attachments
+             WHERE (file_path IS NULL OR file_path = '')
+               AND data_base64 != ''
+               AND length(data_base64) > 0
+             LIMIT ?`,
+          )
+          .all(BATCH_SIZE) as Array<{
+          id: string;
+          original_filename: string;
+          data_base64: string;
+        }>;
+
+        if (rows.length === 0) break;
+
+        for (const row of rows) {
+          const filePath = writeAttachmentToDisk(
+            row.data_base64,
+            row.original_filename,
+          );
+          raw
+            .query(
+              `UPDATE attachments SET file_path = ?, data_base64 = '' WHERE id = ?`,
+            )
+            .run(filePath, row.id);
+        }
+
+        totalMigrated += rows.length;
+      }
+
+      if (totalMigrated > 0) {
+        // Log is intentionally not imported to keep migration self-contained;
+        // the checkpoint value records completion.
+        console.log(`Migrated ${totalMigrated} inline attachments to disk`);
+      }
+    },
+  );
+}