@vellumai/assistant 0.5.2 → 0.5.3

package/src/memory/indexer.ts

@@ -5,6 +5,7 @@ import { getConfig } from "../config/loader.js";
 import type { MemoryConfig } from "../config/types.js";
 import type { TrustClass } from "../runtime/actor-trust-resolver.js";
 import { getLogger } from "../util/logger.js";
+import { computeChunkContentHash } from "./archive-store.js";
 import { getDb } from "./db.js";
 import { selectedBackendSupportsMultimodal } from "./embedding-backend.js";
 import { enqueueMemoryJob } from "./jobs-store.js";
@@ -12,7 +13,7 @@ import {
   extractMediaBlockMeta,
   extractTextFromStoredMessageContent,
 } from "./message-content.js";
-import { memorySegments } from "./schema.js";
+import { memoryChunks, memoryObservations, memorySegments } from "./schema.js";
 import { segmentText } from "./segmenter.js";
 
 const log = getLogger("memory-indexer");
@@ -53,7 +54,12 @@ export async function indexMessageNow(
     input.provenanceTrustClass === undefined;
 
   const text = extractTextFromStoredMessageContent(input.content);
-  if (text.length === 0) {
+  const hasText = text.length > 0;
+  const candidateMediaMeta = extractMediaBlockMeta(input.content).filter(
+    (b) => b.type === "image",
+  );
+  const hasMedia = candidateMediaMeta.length > 0;
+  if (!hasText && !hasMedia) {
     enqueueMemoryJob("build_conversation_summary", {
       conversationId: input.conversationId,
     });
@@ -62,11 +68,13 @@ export async function indexMessageNow(
 
   const db = getDb();
   const now = Date.now();
-  const segments = segmentText(
-    text,
-    config.segmentation.targetTokens,
-    config.segmentation.overlapTokens,
-  );
+  const segments = hasText
+    ? segmentText(
+        text,
+        config.segmentation.targetTokens,
+        config.segmentation.overlapTokens,
+      )
+    : [];
   const shouldExtract =
     input.role === "user" ||
     (input.role === "assistant" && config.extraction.extractFromAssistant);
@@ -76,9 +84,6 @@ export async function indexMessageNow(
   // overhead for messages on non-multimodal backends.
   // selectedBackendSupportsMultimodal requires async key resolution, so we
   // skip it entirely for text-only messages.
-  const candidateMediaMeta = extractMediaBlockMeta(input.content).filter(
-    (b) => b.type === "image",
-  );
   const mediaBlocks =
     candidateMediaMeta.length > 0 &&
     (await selectedBackendSupportsMultimodal(getConfig()))
@@ -88,7 +93,10 @@ export async function indexMessageNow(
   // Wrap all segment inserts and job enqueues in a single transaction so they
   // either all succeed or all roll back, preventing partial/orphaned state.
   let skippedEmbedJobs = 0;
+  let skippedChunkEmbedJobs = 0;
+  const scopeId = input.scopeId ?? "default";
   db.transaction((tx) => {
+    // ── Legacy segment path (kept intact for parallel validation) ───
     for (const segment of segments) {
       const segmentId = buildSegmentId(input.messageId, segment.segmentIndex);
       const hash = createHash("sha256").update(segment.text).digest("hex");
@@ -109,7 +117,7 @@ export async function indexMessageNow(
           segmentIndex: segment.segmentIndex,
           text: segment.text,
           tokenEstimate: segment.tokenEstimate,
-          scopeId: input.scopeId ?? "default",
+          scopeId,
           contentHash: hash,
           createdAt: input.createdAt,
           updatedAt: now,
@@ -119,7 +127,7 @@ export async function indexMessageNow(
           set: {
             text: segment.text,
             tokenEstimate: segment.tokenEstimate,
-            scopeId: input.scopeId ?? "default",
+            scopeId,
             contentHash: hash,
             updatedAt: now,
           },
@@ -133,6 +141,65 @@ export async function indexMessageNow(
       }
     }
 
+    // ── Archive chunk dual-write (mirrors segment boundaries) ──────
+    // Create a single observation per message, then create one chunk per
+    // segment using the same segmentation boundaries. Chunks are
+    // deduplicated by (scopeId, contentHash) via onConflictDoNothing so
+    // unchanged content does not enqueue duplicate embed_chunk jobs.
+    const observationId = buildObservationId(input.messageId);
+    tx.insert(memoryObservations)
+      .values({
+        id: observationId,
+        scopeId,
+        conversationId: input.conversationId,
+        messageId: input.messageId,
+        role: input.role,
+        content: hasText ? text : input.content,
+        modality: hasMedia ? "multimodal" : "text",
+        source: null,
+        createdAt: input.createdAt,
+      })
+      .onConflictDoNothing({ target: memoryObservations.id })
+      .run();
+
+    for (const segment of segments) {
+      const chunkId = buildChunkId(input.messageId, segment.segmentIndex);
+      const chunkHash = computeChunkContentHash(scopeId, segment.text);
+
+      // Check if this chunk already exists with the same content hash
+      const existingChunk = tx
+        .select({ contentHash: memoryChunks.contentHash })
+        .from(memoryChunks)
+        .where(eq(memoryChunks.id, chunkId))
+        .get();
+
+      tx.insert(memoryChunks)
+        .values({
+          id: chunkId,
+          scopeId,
+          observationId,
+          content: segment.text,
+          tokenEstimate: segment.tokenEstimate,
+          contentHash: chunkHash,
+          createdAt: input.createdAt,
+        })
+        .onConflictDoUpdate({
+          target: memoryChunks.id,
+          set: {
+            content: segment.text,
+            tokenEstimate: segment.tokenEstimate,
+            contentHash: chunkHash,
+          },
+        })
+        .run();
+
+      if (existingChunk?.contentHash === chunkHash) {
+        skippedChunkEmbedJobs++;
+      } else {
+        enqueueMemoryJob("embed_chunk", { chunkId, scopeId }, Date.now(), tx);
+      }
+    }
+
     // Enqueue embed_attachment jobs for image content blocks when the
     // embedding provider supports multimodal (Gemini only).
     for (const block of mediaBlocks) {
@@ -147,7 +214,7 @@ export async function indexMessageNow(
     if (shouldExtract && isTrustedActor && !input.automated) {
       enqueueMemoryJob(
         "extract_items",
-        { messageId: input.messageId, scopeId: input.scopeId ?? "default" },
+        { messageId: input.messageId, scopeId },
         Date.now(),
         tx,
       );
@@ -166,6 +233,12 @@ export async function indexMessageNow(
     );
   }
 
+  if (skippedChunkEmbedJobs > 0) {
+    log.debug(
+      `Skipped ${skippedChunkEmbedJobs}/${segments.length} embed_chunk jobs (content unchanged)`,
+    );
+  }
+
   if (!isTrustedActor && shouldExtract) {
     log.info(
       `Skipping extraction jobs for untrusted actor (trustClass=${input.provenanceTrustClass})`,
@@ -177,9 +250,11 @@ export async function indexMessageNow(
   }
 
   const extractionGated = !isTrustedActor || !!input.automated;
+  const segmentEmbedJobs = segments.length - skippedEmbedJobs;
+  const chunkEmbedJobs = segments.length - skippedChunkEmbedJobs;
   const enqueuedJobs =
-    segments.length -
-    skippedEmbedJobs +
+    segmentEmbedJobs +
+    chunkEmbedJobs +
     mediaBlocks.length +
     (shouldExtract && !extractionGated ? 2 : 1);
   return {
@@ -213,3 +288,19 @@ export function getRecentSegmentsForConversation(
 function buildSegmentId(messageId: string, segmentIndex: number): string {
   return `${messageId}:${segmentIndex}`;
 }
+
+/**
+ * Deterministic observation ID derived from the messageId so repeated
+ * indexer runs for the same message converge on the same observation row.
+ */
+function buildObservationId(messageId: string): string {
+  return `obs:${messageId}`;
+}
+
+/**
+ * Deterministic chunk ID derived from the messageId and segment index so
+ * the dual-write path mirrors the legacy segment identity scheme exactly.
+ */
+function buildChunkId(messageId: string, segmentIndex: number): string {
+  return `chunk:${messageId}:${segmentIndex}`;
+}

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

@@ -183,6 +183,7 @@ describe("embedMediaJob", () => {
     expect(call.extraPayload).toEqual({
       created_at: now,
       kind: "image",
+      memory_scope_id: "default",
       subject: "My Screenshot",
     });
   });

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/migrations/185-memory-brief-state.ts

@@ -0,0 +1,52 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Create the memory brief state tables: time_contexts and open_loops.
+ *
+ * Both tables use CREATE TABLE IF NOT EXISTS and CREATE INDEX IF NOT EXISTS,
+ * making this migration inherently idempotent — safe to re-run on every startup
+ * without a checkpoint guard.
+ */
+export function migrateMemoryBriefState(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // -- time_contexts: bounded temporal windows for the brief --
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS time_contexts (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      source TEXT NOT NULL,
+      active_from INTEGER NOT NULL,
+      active_until INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_time_contexts_scope_active_until
+    ON time_contexts (scope_id, active_until)
+  `);
+
+  // -- open_loops: unresolved items the brief should surface --
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS open_loops (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      status TEXT NOT NULL DEFAULT 'open',
+      source TEXT NOT NULL,
+      due_at INTEGER,
+      surfaced_at INTEGER,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_open_loops_scope_status_due
+    ON open_loops (scope_id, status, due_at)
+  `);
+}

package/src/memory/migrations/186-memory-archive.ts

@@ -0,0 +1,109 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+/**
+ * Create the memory archive tables (memory_observations, memory_chunks,
+ * memory_episodes) with prefetch indexes on scopeId, conversationId, and
+ * createdAt.
+ *
+ * All statements use IF NOT EXISTS / IF NOT EXISTS guards so the migration
+ * is safe to re-run on every startup.
+ */
+export function migrateMemoryArchiveTables(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+
+  // -- memory_observations --------------------------------------------------
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_observations (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL DEFAULT 'default',
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      message_id TEXT REFERENCES messages(id) ON DELETE SET NULL,
+      role TEXT NOT NULL,
+      content TEXT NOT NULL,
+      modality TEXT NOT NULL DEFAULT 'text',
+      source TEXT,
+      created_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_observations_scope_id
+    ON memory_observations (scope_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_observations_conversation_id
+    ON memory_observations (conversation_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_observations_created_at
+    ON memory_observations (created_at)
+  `);
+
+  // -- memory_chunks --------------------------------------------------------
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_chunks (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL DEFAULT 'default',
+      observation_id TEXT NOT NULL REFERENCES memory_observations(id) ON DELETE CASCADE,
+      content TEXT NOT NULL,
+      token_estimate INTEGER NOT NULL,
+      content_hash TEXT NOT NULL,
+      created_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_chunks_scope_id
+    ON memory_chunks (scope_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_chunks_observation_id
+    ON memory_chunks (observation_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE UNIQUE INDEX IF NOT EXISTS idx_memory_chunks_content_hash
+    ON memory_chunks (scope_id, content_hash)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_chunks_created_at
+    ON memory_chunks (created_at)
+  `);
+
+  // -- memory_episodes ------------------------------------------------------
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_episodes (
+      id TEXT PRIMARY KEY,
+      scope_id TEXT NOT NULL DEFAULT 'default',
+      conversation_id TEXT NOT NULL REFERENCES conversations(id) ON DELETE CASCADE,
+      title TEXT NOT NULL,
+      summary TEXT NOT NULL,
+      token_estimate INTEGER NOT NULL,
+      source TEXT,
+      start_at INTEGER NOT NULL,
+      end_at INTEGER NOT NULL,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_episodes_scope_id
+    ON memory_episodes (scope_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_episodes_conversation_id
+    ON memory_episodes (conversation_id)
+  `);
+
+  raw.exec(/*sql*/ `
+    CREATE INDEX IF NOT EXISTS idx_memory_episodes_created_at
+    ON memory_episodes (created_at)
+  `);
+}

package/src/memory/migrations/187-memory-reducer-checkpoints.ts

@@ -0,0 +1,19 @@
+import type { DrizzleDb } from "../db-connection.js";
+import { getSqliteFrom } from "../db-connection.js";
+
+export function migrateMemoryReducerCheckpoints(database: DrizzleDb): void {
+  const raw = getSqliteFrom(database);
+  const columns = [
+    "memory_reduced_through_message_id TEXT",
+    "memory_dirty_tail_since_message_id TEXT",
+    "memory_last_reduced_at INTEGER",
+  ];
+
+  for (const column of columns) {
+    try {
+      raw.exec(`ALTER TABLE conversations ADD COLUMN ${column}`);
+    } catch {
+      // Column already exists — nothing to do.
+    }
+  }
+}

package/src/memory/migrations/index.ts

@@ -126,6 +126,9 @@ export { migrateRenameThreadStartersCheckpoints } from "./181-rename-thread-star
 export { migrateOAuthProvidersDisplayMetadata } from "./182-oauth-providers-display-metadata.js";
 export { migrateConversationForkLineage } from "./183-add-conversation-fork-lineage.js";
 export { migrateLlmRequestLogProvider } from "./184-llm-request-log-provider.js";
+export { migrateMemoryBriefState } from "./185-memory-brief-state.js";
+export { migrateMemoryArchiveTables } from "./186-memory-archive.js";
+export { migrateMemoryReducerCheckpoints } from "./187-memory-reducer-checkpoints.js";
 export {
   MIGRATION_REGISTRY,
   type MigrationRegistryEntry,

package/src/memory/qdrant-client.ts

@@ -20,7 +20,7 @@ export interface QdrantClientConfig {
 }
 
 export interface QdrantPointPayload {
-  target_type: "segment" | "item" | "summary" | "media";
+  target_type: "segment" | "item" | "summary" | "observation" | "chunk" | "episode" | "media";
   target_id: string;
   text: string;
   kind?: string;
@@ -230,7 +230,7 @@ export class VellumQdrantClient {
   }
 
   async upsert(
-    targetType: "segment" | "item" | "summary" | "media",
+    targetType: "segment" | "item" | "summary" | "observation" | "chunk" | "episode" | "media",
     targetId: string,
     vector: number[],
     payload: Omit<QdrantPointPayload, "target_type" | "target_id">,
@@ -324,8 +324,11 @@ export class VellumQdrantClient {
   async searchWithFilter(
     vector: number[],
     limit: number,
-    targetTypes: Array<"segment" | "item" | "summary" | "media">,
+    targetTypes: Array<
+      "segment" | "item" | "summary" | "media" | "chunk" | "episode"
+    >,
     excludeMessageIds?: string[],
+    scopeIds?: string[],
   ): Promise<QdrantSearchResult[]> {
     const mustConditions: Array<Record<string, unknown>> = [
       {
@@ -346,12 +349,24 @@ export class VellumQdrantClient {
           },
           {
             key: "target_type",
-            match: { any: ["segment", "summary", "media"] },
+            match: { any: ["segment", "summary", "media", "chunk"] },
           },
         ],
       });
     }
 
+    // Scope filtering: accept points whose memory_scope_id matches one of the
+    // allowed scopes, OR points that lack the field entirely (legacy data).
+    // Post-query DB filtering remains as defense-in-depth for legacy points.
+    if (scopeIds && scopeIds.length > 0) {
+      mustConditions.push({
+        should: [
+          { key: "memory_scope_id", match: { any: scopeIds } },
+          { is_empty: { key: "memory_scope_id" } },
+        ],
+      });
+    }
+
     const mustNotConditions: Array<Record<string, unknown>> = [
       { key: "_meta", match: { value: true } },
     ];
@@ -561,6 +576,10 @@ export class VellumQdrantClient {
         field_name: "modality",
         field_schema: "keyword",
       }),
+      this.client.createPayloadIndex(this.collection, {
+        field_name: "memory_scope_id",
+        field_schema: "keyword",
+      }),
     ]);
   }