@vellumai/assistant 0.10.7 → 0.10.8-dev.202607102228.5945895

package/src/plugins/defaults/memory/graph/extraction.ts

@@ -10,20 +10,22 @@ import { readFileSync } from "node:fs";
 import { join } from "node:path";
 
 import type { ContentBlock, ImageContent, Message } from "@vellumai/plugin-api";
-import { getConfiguredProvider } from "@vellumai/plugin-api";
+import {
+  getConfiguredProvider,
+  getConversationDirPath,
+} from "@vellumai/plugin-api";
 import { and, asc, desc, eq, gt } from "drizzle-orm";
 
 import type { AssistantConfig } from "../../../../config/types.js";
-import { getConversationDirPath } from "../../../../persistence/conversation-disk-view.js";
 import { getDb } from "../../../../persistence/db-connection.js";
 import {
   conversations,
   messages,
 } from "../../../../persistence/schema/index.js";
-import { buildCoreIdentityContext } from "../../../../prompts/system-prompt.js";
-import { BackendUnavailableError } from "../../../../util/errors.js";
-import { getLogger } from "../../../../util/logger.js";
+import { BackendUnavailableError } from "../host-utils.js";
+import { buildIdentityContext } from "../identity-context.js";
 import { extractToolUse, userMessage } from "../llm-helpers.js";
+import { getLogger } from "../logging.js";
 import {
   enqueueGraphNodeEmbed,
   enqueueGraphTriggerEmbed,
@@ -557,7 +559,9 @@ function clamp(v: number, min: number, max: number): number {
 
 /** Coerce an LLM-returned event_date to number | null, guarding against string values. */
 export function parseEpochMs(value: unknown): number | null {
-  if (value == null || value === "") return null;
+  if (value == null || value === "") {
+    return null;
+  }
   const n = Number(value);
   return Number.isFinite(n) ? n : null;
 }
@@ -581,7 +585,6 @@ export interface DeferredEdge {
 export function parseExtractionResponse(
   input: Record<string, unknown>,
   conversationId: string,
-  scopeId: string,
   candidateNodeIds: Set<string>,
   /** Epoch ms — when the conversation happened (not extraction time). */
   conversationTimestamp: number,
@@ -631,8 +634,12 @@ export function parseExtractionResponse(
   // Parse new nodes
   for (let i = 0; i < createNodes.length; i++) {
     const raw = createNodes[i];
-    if (!raw.content || typeof raw.content !== "string") continue;
-    if (!raw.type || !VALID_TYPES.has(raw.type)) continue;
+    if (!raw.content || typeof raw.content !== "string") {
+      continue;
+    }
+    if (!raw.type || !VALID_TYPES.has(raw.type)) {
+      continue;
+    }
 
     const charge = raw.emotional_charge ?? {};
     const emotionalCharge: EmotionalCharge = {
@@ -666,7 +673,6 @@ export function parseExtractionResponse(
       narrativeRole: null,
       partOfStory: null,
       imageRefs: null,
-      scopeId,
     };
 
     // Prospective nodes (tasks, plans, upcoming events) are inherently transient.
@@ -695,7 +701,9 @@ export function parseExtractionResponse(
     // Collect triggers
     if (Array.isArray(raw.triggers)) {
       for (const t of raw.triggers) {
-        if (!t.type || !VALID_TRIGGER_TYPES.has(t.type)) continue;
+        if (!t.type || !VALID_TRIGGER_TYPES.has(t.type)) {
+          continue;
+        }
         deferredTriggers.push({
           newNodeIndex: nodeIndex,
           trigger: {
@@ -762,16 +770,23 @@ export function parseExtractionResponse(
     if (Array.isArray(raw.image_refs)) {
       const validRefs: ImageRef[] = [];
       for (const ref of raw.image_refs) {
-        if (!ref.message_id || typeof ref.message_id !== "string") continue;
-        if (typeof ref.block_index !== "number" || ref.block_index < 0)
+        if (!ref.message_id || typeof ref.message_id !== "string") {
+          continue;
+        }
+        if (typeof ref.block_index !== "number" || ref.block_index < 0) {
+          continue;
+        }
+        if (!ref.description || typeof ref.description !== "string") {
           continue;
-        if (!ref.description || typeof ref.description !== "string") continue;
+        }
         const mimeType = resolveImageRefMimeType(
           ref.message_id,
           ref.block_index,
           conversationId,
         );
-        if (!mimeType) continue;
+        if (!mimeType) {
+          continue;
+        }
         validRefs.push({
           messageId: ref.message_id,
           blockIndex: ref.block_index,
@@ -791,18 +806,30 @@ export function parseExtractionResponse(
   for (let i = 0; i < createNodes.length; i++) {
     const raw = createNodes[i];
     const tempId = raw?.temp_id;
-    if (typeof tempId !== "string" || tempId.length === 0) continue;
-    if (candidateNodeIds.has(tempId)) continue;
-    if (tempIdToDiffIndex.has(tempId)) continue; // first writer wins
+    if (typeof tempId !== "string" || tempId.length === 0) {
+      continue;
+    }
+    if (candidateNodeIds.has(tempId)) {
+      continue;
+    }
+    if (tempIdToDiffIndex.has(tempId)) {
+      continue;
+    } // first writer wins
     const diffIndex = rawIndexToDiffIndex.get(i);
-    if (diffIndex == null) continue; // raw node was rejected during validation
+    if (diffIndex == null) {
+      continue;
+    } // raw node was rejected during validation
     tempIdToDiffIndex.set(tempId, diffIndex);
   }
 
   const resolveEndpoint = (id: string): DeferredEdgeEndpoint | null => {
-    if (candidateNodeIds.has(id)) return { kind: "existing", nodeId: id };
+    if (candidateNodeIds.has(id)) {
+      return { kind: "existing", nodeId: id };
+    }
     const idx = tempIdToDiffIndex.get(id);
-    if (idx != null) return { kind: "new", newNodeIndex: idx };
+    if (idx != null) {
+      return { kind: "new", newNodeIndex: idx };
+    }
     return null;
   };
 
@@ -833,22 +860,32 @@ export function parseExtractionResponse(
   for (let i = 0; i < createNodes.length; i++) {
     const raw = createNodes[i];
     const sourceDiffIndex = rawIndexToDiffIndex.get(i);
-    if (sourceDiffIndex == null) continue;
-    if (!Array.isArray(raw.edges_to_existing)) continue;
+    if (sourceDiffIndex == null) {
+      continue;
+    }
+    if (!Array.isArray(raw.edges_to_existing)) {
+      continue;
+    }
 
     for (const edge of raw.edges_to_existing) {
-      if (!edge.target_node_id) continue;
-      if (!edge.relationship || !VALID_RELATIONSHIPS.has(edge.relationship))
+      if (!edge.target_node_id) {
+        continue;
+      }
+      if (!edge.relationship || !VALID_RELATIONSHIPS.has(edge.relationship)) {
         continue;
+      }
       const target = resolveEndpoint(edge.target_node_id);
-      if (!target) continue;
+      if (!target) {
+        continue;
+      }
       const source: DeferredEdgeEndpoint = {
         kind: "new",
         newNodeIndex: sourceDiffIndex,
       };
       // Skip self-loops.
-      if (target.kind === "new" && target.newNodeIndex === sourceDiffIndex)
+      if (target.kind === "new" && target.newNodeIndex === sourceDiffIndex) {
         continue;
+      }
       pushResolvedEdge(
         source,
         target,
@@ -860,20 +897,28 @@ export function parseExtractionResponse(
 
   // Parse updates
   for (const raw of updateNodes) {
-    if (!raw.id || !candidateNodeIds.has(raw.id)) continue;
+    if (!raw.id || !candidateNodeIds.has(raw.id)) {
+      continue;
+    }
     const changes: Record<string, unknown> = {};
-    if (raw.content) changes.content = raw.content;
-    if (raw.significance != null)
+    if (raw.content) {
+      changes.content = raw.content;
+    }
+    if (raw.significance != null) {
       changes.significance = clamp(raw.significance, 0, 1);
-    if (raw.confidence != null)
+    }
+    if (raw.confidence != null) {
       changes.confidence = clamp(raw.confidence, 0, 1);
+    }
     if (
       raw.fidelity &&
       ["vivid", "clear", "faded", "gist"].includes(raw.fidelity)
-    )
+    ) {
       changes.fidelity = raw.fidelity;
-    if (raw.event_date !== undefined)
+    }
+    if (raw.event_date !== undefined) {
       changes.eventDate = parseEpochMs(raw.event_date);
+    }
     if (Object.keys(changes).length > 0) {
       diff.updateNodes.push({ id: raw.id, changes });
     }
@@ -882,25 +927,32 @@ export function parseExtractionResponse(
   // Parse top-level edges — each endpoint may be an existing candidate ID or
   // the temp_id of a new node declared in create_nodes.
   for (const raw of newEdges) {
-    if (!raw.source_node_id || !raw.target_node_id) continue;
-    if (!raw.relationship || !VALID_RELATIONSHIPS.has(raw.relationship))
+    if (!raw.source_node_id || !raw.target_node_id) {
+      continue;
+    }
+    if (!raw.relationship || !VALID_RELATIONSHIPS.has(raw.relationship)) {
       continue;
+    }
     const source = resolveEndpoint(raw.source_node_id);
     const target = resolveEndpoint(raw.target_node_id);
-    if (!source || !target) continue;
+    if (!source || !target) {
+      continue;
+    }
     // Skip self-loops.
     if (
       source.kind === "new" &&
       target.kind === "new" &&
       source.newNodeIndex === target.newNodeIndex
-    )
+    ) {
       continue;
+    }
     if (
       source.kind === "existing" &&
       target.kind === "existing" &&
       source.nodeId === target.nodeId
-    )
+    ) {
       continue;
+    }
     pushResolvedEdge(
       source,
       target,
@@ -937,7 +989,6 @@ export interface ExtractionResult {
  */
 export async function runGraphExtraction(
   conversationId: string,
-  scopeId: string,
   config: AssistantConfig,
   opts?: {
     /** Pre-loaded transcript text (skips disk read). Used by bootstrap. */
@@ -977,7 +1028,8 @@ export async function runGraphExtraction(
   let transcript = opts?.transcript;
   if (!transcript) {
     transcript =
-      loadTranscriptFromDisk(conversationId, opts?.afterTimestamp) ?? undefined;
+      (await loadTranscriptFromDisk(conversationId, opts?.afterTimestamp)) ??
+      undefined;
     if (!transcript) {
       // If we have a multimodal result but no disk transcript, extract text
       // from the multimodal message content blocks for candidate search.
@@ -1013,7 +1065,6 @@ export async function runGraphExtraction(
   // 3. Find candidate existing nodes
   const candidateNodes = await findCandidateNodes(
     transcript,
-    scopeId,
     config,
     opts?.activeContextNodeIds,
     opts?.skipQdrant,
@@ -1021,7 +1072,7 @@ export async function runGraphExtraction(
   const candidateNodeIds = new Set(candidateNodes.map((n) => n.id));
 
   // 4. Build prompt
-  const identityContext = buildCoreIdentityContext();
+  const identityContext = buildIdentityContext();
 
   const activeSet = opts?.activeContextNodeIds
     ? new Set(opts.activeContextNodeIds)
@@ -1085,7 +1136,6 @@ export async function runGraphExtraction(
   const { diff, deferredEdges, deferredTriggers } = parseExtractionResponse(
     toolBlock.input as Record<string, unknown>,
     conversationId,
-    scopeId,
     candidateNodeIds,
     conversationTimestamp,
   );
@@ -1115,14 +1165,18 @@ export async function runGraphExtraction(
   let triggersCreated = result.triggersCreated;
 
   const resolveCreatedEndpoint = (ep: DeferredEdgeEndpoint): string | null => {
-    if (ep.kind === "existing") return ep.nodeId;
+    if (ep.kind === "existing") {
+      return ep.nodeId;
+    }
     return createdNodeIds[ep.newNodeIndex] ?? null;
   };
 
   for (const de of deferredEdges) {
     const sourceNodeId = resolveCreatedEndpoint(de.source);
     const targetNodeId = resolveCreatedEndpoint(de.target);
-    if (!sourceNodeId || !targetNodeId) continue;
+    if (!sourceNodeId || !targetNodeId) {
+      continue;
+    }
 
     createEdge({
       sourceNodeId,
@@ -1138,7 +1192,9 @@ export async function runGraphExtraction(
 
   for (const dt of deferredTriggers) {
     const newNodeId = createdNodeIds[dt.newNodeIndex];
-    if (!newNodeId) continue;
+    if (!newNodeId) {
+      continue;
+    }
 
     const trigger = createTrigger({
       ...dt.trigger,
@@ -1211,7 +1267,9 @@ function resolveConversationTimestamp(conversationId: string): number | null {
     .orderBy(desc(messages.createdAt))
     .limit(1)
     .get();
-  if (lastMsg) return lastMsg.createdAt;
+  if (lastMsg) {
+    return lastMsg.createdAt;
+  }
 
   // Fallback to conversation creation time if no messages in DB
   const conv = db
@@ -1235,10 +1293,13 @@ function resolveImageRefMimeType(
       and(
         eq(messages.id, messageId),
         eq(messages.conversationId, conversationId),
+        eq(messages.finalized, 1),
       ),
     )
     .get();
-  if (!msg) return null;
+  if (!msg) {
+    return null;
+  }
 
   try {
     const blocks = JSON.parse(msg.content) as Array<{
@@ -1246,17 +1307,19 @@ function resolveImageRefMimeType(
       source?: { media_type?: string };
     }>;
     const block = blocks[blockIndex];
-    if (!block || block.type !== "image") return null;
+    if (!block || block.type !== "image") {
+      return null;
+    }
     return block.source?.media_type ?? null;
   } catch {
     return null;
   }
 }
 
-function loadTranscriptFromDisk(
+async function loadTranscriptFromDisk(
   conversationId: string,
   afterTimestamp?: number,
-): string | null {
+): Promise<string | null> {
   const db = getDb();
   const conv = db
     .select({ createdAt: conversations.createdAt })
@@ -1264,10 +1327,15 @@ function loadTranscriptFromDisk(
     .where(eq(conversations.id, conversationId))
     .get();
 
-  if (!conv) return null;
+  if (!conv) {
+    return null;
+  }
 
   try {
-    const dirPath = getConversationDirPath(conversationId, conv.createdAt);
+    const dirPath = await getConversationDirPath(
+      conversationId,
+      conv.createdAt,
+    );
     const messagesPath = join(dirPath, "messages.jsonl");
     const content = readFileSync(messagesPath, "utf-8");
 
@@ -1284,12 +1352,16 @@ function loadTranscriptFromDisk(
           content?: string;
           ts?: string;
         };
-        if (!msg.role || !msg.content) continue;
+        if (!msg.role || !msg.content) {
+          continue;
+        }
 
         // Filter by timestamp for incremental extraction
         if (afterTimestamp && msg.ts) {
           const msgTime = new Date(msg.ts).getTime();
-          if (msgTime <= afterTimestamp) continue;
+          if (msgTime <= afterTimestamp) {
+            continue;
+          }
         }
 
         parts.push(`[${msg.role}]: ${msg.content}`);
@@ -1323,7 +1395,10 @@ function loadTranscriptWithImages(
   const db = getDb();
 
   // Build query conditions
-  const conditions = [eq(messages.conversationId, conversationId)];
+  const conditions = [
+    eq(messages.conversationId, conversationId),
+    eq(messages.finalized, 1),
+  ];
   if (afterTimestamp !== undefined) {
     conditions.push(gt(messages.createdAt, afterTimestamp));
   }
@@ -1340,7 +1415,9 @@ function loadTranscriptWithImages(
     .orderBy(asc(messages.createdAt))
     .all();
 
-  if (rows.length === 0) return null;
+  if (rows.length === 0) {
+    return null;
+  }
 
   const MAX_IMAGES = 10;
   let imageCount = 0;
@@ -1396,7 +1473,9 @@ function loadTranscriptWithImages(
   }
 
   // Skip if transcript is too short (images count toward the threshold)
-  if (totalTextLength < 100 && !hasImagesFlag) return null;
+  if (totalTextLength < 100 && !hasImagesFlag) {
+    return null;
+  }
 
   const message: Message = {
     role: "user",
@@ -1408,7 +1487,6 @@ function loadTranscriptWithImages(
 
 async function findCandidateNodes(
   transcript: string,
-  scopeId: string,
   config: AssistantConfig,
   activeContextNodeIds?: string[],
   skipQdrant?: boolean,
@@ -1419,11 +1497,12 @@ async function findCandidateNodes(
     // Bootstrap mode: load candidates directly from DB (embeddings may not be ready).
     // Get the most recent and most significant non-gone nodes.
     const dbCandidates = queryNodes({
-      scopeId,
       fidelityNot: ["gone"],
       limit: 100,
     });
-    for (const node of dbCandidates) allNodeIds.add(node.id);
+    for (const node of dbCandidates) {
+      allNodeIds.add(node.id);
+    }
   } else {
     // Live mode: semantic search via Qdrant
     const { embedWithRetry } =
@@ -1438,7 +1517,9 @@ async function findCandidateNodes(
       const queryVector = embedding.vectors[0];
       if (queryVector) {
         const searchResults = await searchGraphNodes(queryVector, 100);
-        for (const r of searchResults) allNodeIds.add(r.nodeId);
+        for (const r of searchResults) {
+          allNodeIds.add(r.nodeId);
+        }
       }
     } catch (err) {
       log.warn(
@@ -1450,10 +1531,14 @@ async function findCandidateNodes(
 
   // Combine with active context nodes
   if (activeContextNodeIds) {
-    for (const id of activeContextNodeIds) allNodeIds.add(id);
+    for (const id of activeContextNodeIds) {
+      allNodeIds.add(id);
+    }
   }
 
-  if (allNodeIds.size === 0) return [];
+  if (allNodeIds.size === 0) {
+    return [];
+  }
 
   return getNodesByIds([...allNodeIds]);
 }

package/src/plugins/defaults/memory/graph/graph-search.test.ts

@@ -1,7 +1,5 @@
 import { beforeEach, describe, expect, mock, test } from "bun:test";
 
-import { makeMockLogger } from "../../../../__tests__/helpers/mock-logger.js";
-
 // This test exercises the v1 graph search path. `config.memory.v2.enabled`
 // (default `true`) makes graph-search short-circuit to keep traffic off
 // the legacy collection — force it off so the v1 path stays under test.
@@ -9,10 +7,6 @@ mock.module("../../../../config/loader.js", () => ({
   getConfig: () => ({ memory: { v2: { enabled: false } } }),
 }));
 
-mock.module("../../../../util/logger.js", () => ({
-  getLogger: () => makeMockLogger(),
-}));
-
 let breakerOpen = false;
 const hybridSearchCalls: Array<{
   denseVector: number[];

package/src/plugins/defaults/memory/graph/graph-search.ts

@@ -2,6 +2,11 @@
 // Memory Graph — Qdrant vector search for graph nodes
 // ---------------------------------------------------------------------------
 
+import {
+  embedAndUpsert,
+  selectedBackendSupportsMultimodal,
+} from "@vellumai/plugin-api";
+
 import { getConfig } from "../../../../config/loader.js";
 import type { AssistantConfig } from "../../../../config/types.js";
 import type { EmbeddingInput } from "../../../../persistence/embeddings/embedding-types.js";
@@ -18,11 +23,7 @@ import {
   isMemoryEnabled,
   type MemoryJob,
 } from "../../../../persistence/jobs-store.js";
-import { getLogger } from "../../../../util/logger.js";
-import {
-  embedAndUpsert,
-  selectedBackendSupportsMultimodal,
-} from "../embeddings.js";
+import { getLogger } from "../logging.js";
 import { loadImageRefData } from "./image-ref-utils.js";
 import { getNode } from "./store.js";
 import type { MemoryNode } from "./types.js";
@@ -55,7 +56,9 @@ export async function searchGraphNodes(
   // active retirement and a corrupted sparse segment can OOM-crash the
   // shared Qdrant process — short-circuiting here keeps v1 background work
   // and stale callers from taking v2 down with them.
-  if (getConfig().memory.v2.enabled) return [];
+  if (getConfig().memory.v2.enabled) {
+    return [];
+  }
 
   if (isQdrantBreakerOpen()) {
     log.warn("Qdrant circuit breaker open, skipping graph search");
@@ -168,12 +171,13 @@ function formatNodeForEmbedding(node: MemoryNode): string {
  * to text embedding with image description suffixes otherwise.
  */
 export async function embedGraphNodeDirect(node: MemoryNode): Promise<void> {
-  if (node.fidelity === "gone") return;
+  if (node.fidelity === "gone") {
+    return;
+  }
 
   const text = formatNodeForEmbedding(node);
   const extraPayload: Record<string, unknown> = {
     created_at: node.created,
-    memory_scope_id: node.scopeId,
     confidence: node.confidence,
     importance: node.significance,
     kind: node.type,
@@ -220,10 +224,14 @@ export async function embedGraphNodeDirect(node: MemoryNode): Promise<void> {
  */
 export async function embedGraphNodeJob(job: MemoryJob): Promise<void> {
   const nodeId = asString(job.payload.nodeId);
-  if (!nodeId) return;
+  if (!nodeId) {
+    return;
+  }
 
   const node = getNode(nodeId);
-  if (!node) return;
+  if (!node) {
+    return;
+  }
 
   await embedGraphNodeDirect(node);
 }
@@ -232,7 +240,9 @@ export async function embedGraphNodeJob(job: MemoryJob): Promise<void> {
  * Enqueue an embedding job for a graph node (async, for live conversations).
  */
 export function enqueueGraphNodeEmbed(nodeId: string): void {
-  if (!isMemoryEnabled()) return;
+  if (!isMemoryEnabled()) {
+    return;
+  }
   enqueueMemoryJob("embed_graph_node", { nodeId });
 }
 
@@ -245,7 +255,9 @@ export async function embedGraphTriggerJob(
   config: AssistantConfig,
 ): Promise<void> {
   const triggerId = asString(job.payload.triggerId);
-  if (!triggerId) return;
+  if (!triggerId) {
+    return;
+  }
 
   // Import here to avoid circular dependency
   const { getDb } = await import("../../../../persistence/db-connection.js");
@@ -261,11 +273,15 @@ export async function embedGraphTriggerJob(
     .where(eq(memoryGraphTriggers.id, triggerId))
     .get();
 
-  if (!row || !row.condition) return;
+  if (!row || !row.condition) {
+    return;
+  }
 
   const result = await embedWithBackend(config, [row.condition]);
   const vector = result.vectors[0];
-  if (!vector) return;
+  if (!vector) {
+    return;
+  }
 
   const buffer = Buffer.from(new Float32Array(vector).buffer);
   db.update(memoryGraphTriggers)
@@ -278,6 +294,8 @@ export async function embedGraphTriggerJob(
  * Enqueue a trigger embedding job.
  */
 export function enqueueGraphTriggerEmbed(triggerId: string): void {
-  if (!isMemoryEnabled()) return;
+  if (!isMemoryEnabled()) {
+    return;
+  }
   enqueueMemoryJob("graph_trigger_embed", { triggerId });
 }

package/src/plugins/defaults/memory/graph/image-ref-utils.ts

@@ -1,8 +1,8 @@
 import { eq } from "drizzle-orm";
 
 import { getDb } from "../../../../persistence/db-connection.js";
-import { extractMediaBlocks } from "../../../../persistence/message-content.js";
 import { messages } from "../../../../persistence/schema/index.js";
+import { extractMediaBlocks } from "../message-media.js";
 import type { ImageRef } from "./types.js";
 
 /**
@@ -19,11 +19,15 @@ export async function loadImageRefData(
     .from(messages)
     .where(eq(messages.id, ref.messageId))
     .get();
-  if (!msg) return null;
+  if (!msg) {
+    return null;
+  }
 
   const mediaBlocks = extractMediaBlocks(msg.content);
   const block = mediaBlocks.find((b) => b.index === ref.blockIndex);
-  if (!block) return null;
+  if (!block) {
+    return null;
+  }
 
   return { data: block.data, mimeType: block.mimeType };
 }

package/src/plugins/defaults/memory/graph/injection.test.ts

@@ -42,7 +42,6 @@ function makeNode(overrides: Partial<MemoryNode> = {}): MemoryNode {
     narrativeRole: null,
     partOfStory: null,
     imageRefs: null,
-    scopeId: "default",
     ...overrides,
   };
 }

package/src/plugins/defaults/memory/graph/injection.ts

@@ -3,7 +3,7 @@
 // ---------------------------------------------------------------------------
 
 import { optimizeImageForTransport } from "../../../../agent/image-optimize.js";
-import { getLogger } from "../../../../util/logger.js";
+import { getLogger } from "../logging.js";
 import { loadImageRefData } from "./image-ref-utils.js";
 import type { MemoryNode, ScoredNode } from "./types.js";
 import { isCapabilityNode } from "./types.js";