@vellumai/assistant 0.6.4 → 0.6.5

package/src/memory/graph/conversation-graph-memory.ts

@@ -18,6 +18,7 @@ import type {
 } from "../../providers/types.js";
 import { getLogger } from "../../util/logger.js";
 import { getDb } from "../db.js";
+import type { QdrantSparseVector } from "../qdrant-client.js";
 import { memorySummaries } from "../schema.js";
 import { conversations } from "../schema/conversations.js";
 import {
@@ -291,6 +292,32 @@ export class ConversationGraphMemory {
     injectedBlockText: string | null;
     /** Retrieval pipeline metrics (null for noop/error paths). */
     metrics: RetrievalMetrics | null;
+    /**
+     * Dense query vector computed from the retrieval query — recent summaries
+     * for context-load, the last-exchange text for per-turn. Surfaced so
+     * downstream callers (e.g. the PKB hint retriever in
+     * `applyRuntimeInjections`) can reuse the same embedding for a second
+     * Qdrant query without paying for another embedding call. `undefined`
+     * when no text was embedded (image-only turn, empty queries) or the
+     * embedding call failed (circuit breaker).
+     */
+    queryVector?: number[];
+    /** Optional sparse vector accompanying `queryVector`. */
+    sparseVector?: QdrantSparseVector;
+    /**
+     * Dense query vector aligned to the latest user message (PR 3). Surfaced
+     * so callers (PKB hint search) can prefer it over the summary-based
+     * `queryVector`. `undefined` on the per-turn path and when no user-aligned
+     * embed was computed.
+     */
+    userQueryVector?: number[];
+    /**
+     * Sparse (TF-IDF) vector of the user's latest message. Paired with
+     * `userQueryVector` by PKB hint search to run a hybrid dense+sparse
+     * query. `undefined` on the per-turn path and when no user query was
+     * available (empty message or embedding skipped).
+     */
+    userQuerySparseVector?: QdrantSparseVector;
   }> {
     this.tracker.advanceTurn();
 
@@ -317,18 +344,13 @@ export class ConversationGraphMemory {
       // Decide which retrieval mode to use
       if (!this.initialized || this.needsReload) {
         const recentSummaries = this.fetchRecentSummaries();
-
-        // Extract the first user message as an additional retrieval signal
-        // so context-load biases toward what the user is asking about
         const firstUserText = extractUserText(lastMessage);
-        if (firstUserText) {
-          recentSummaries.unshift(firstUserText);
-        }
 
         return await this.runContextLoad(
           messages,
           config,
           recentSummaries,
+          firstUserText ?? undefined,
           abortSignal,
           onEvent,
         );
@@ -352,12 +374,14 @@ export class ConversationGraphMemory {
     messages: Message[],
     config: AssistantConfig,
     recentSummaries: string[],
+    userQuery: string | undefined,
     signal: AbortSignal,
     onEvent: (msg: ServerMessage) => void,
   ) {
     const result = await loadContextMemory({
       scopeId: this.scopeId,
       recentSummaries,
+      userQuery,
       config,
       signal,
     });
@@ -376,6 +400,10 @@ export class ConversationGraphMemory {
         mode: "context-load" as const,
         injectedBlockText: null,
         metrics: result.metrics,
+        queryVector: result.queryVector,
+        sparseVector: result.sparseVector,
+        userQueryVector: result.userQueryVector,
+        userQuerySparseVector: result.userQuerySparseVector,
       };
     }
 
@@ -395,6 +423,10 @@ export class ConversationGraphMemory {
         mode: "context-load" as const,
         injectedBlockText: null,
         metrics: result.metrics,
+        queryVector: result.queryVector,
+        sparseVector: result.sparseVector,
+        userQueryVector: result.userQueryVector,
+        userQuerySparseVector: result.userQuerySparseVector,
       };
     }
 
@@ -427,6 +459,10 @@ export class ConversationGraphMemory {
       mode: "context-load" as const,
       injectedBlockText: contextBlock,
       metrics: result.metrics,
+      queryVector: result.queryVector,
+      sparseVector: result.sparseVector,
+      userQueryVector: result.userQueryVector,
+      userQuerySparseVector: result.userQuerySparseVector,
     };
   }
 
@@ -481,6 +517,8 @@ export class ConversationGraphMemory {
         mode: "per-turn" as const,
         injectedBlockText: null,
         metrics: result.metrics,
+        queryVector: result.queryVector,
+        sparseVector: result.sparseVector,
       };
     }
 
@@ -496,6 +534,8 @@ export class ConversationGraphMemory {
         mode: "per-turn" as const,
         injectedBlockText: null,
         metrics: result.metrics,
+        queryVector: result.queryVector,
+        sparseVector: result.sparseVector,
       };
     }
 
@@ -518,6 +558,8 @@ export class ConversationGraphMemory {
       mode: "per-turn" as const,
       injectedBlockText: injectionBlock,
       metrics: result.metrics,
+      queryVector: result.queryVector,
+      sparseVector: result.sparseVector,
     };
   }
 }
@@ -527,30 +569,18 @@ export class ConversationGraphMemory {
 // ---------------------------------------------------------------------------
 
 /**
- * Remove all memory-injected blocks from the last user message.
- *
- * `injectMemoryBlock` always prepends blocks in this order:
- *   1. For each image: `<memory_image __injected>…` text + `image` + `</memory_image>` text (3-block group)
- *   2. `<memory __injected>…</memory>` text block
- *
- * We strip all leading blocks that match this pattern so that
- * `reinjectCachedMemory` is idempotent — no duplicate images after compaction.
+ * Count the leading content blocks on a user message that were added by
+ * `injectMemoryBlock`. Memory-injected images use a 3-block pattern
+ * (opening `<memory_image>` text + image + closing `</memory_image>` text),
+ * followed by a `<memory __injected>…</memory>` text block. A legacy
+ * 2-block image pattern (no closing tag) is also accepted for backward
+ * compatibility. The injection prefix is always contiguous at the start,
+ * so we stop at the first non-memory block.
  */
-export function stripExistingMemoryInjections(messages: Message[]): Message[] {
-  if (messages.length === 0) return messages;
-  const last = messages[messages.length - 1];
-  if (!last || last.role !== "user") return messages;
-
-  // Walk from the front and skip all memory-injected blocks.
-  // The injection prefix is always contiguous at the start of content.
-  // Memory-injected images use a 3-block pattern: opening <memory_image> text,
-  // image block, closing </memory_image> text (see injectMemoryBlock).
-  // Legacy 2-block pattern (no closing tag) is also handled for backward compat.
-  // Only strip image blocks that follow a marker — user-attached images must be preserved.
+export function countMemoryPrefixBlocks(content: ContentBlock[]): number {
   let firstNonMemory = 0;
   let prevWasMemoryImageMarker = false;
   let prevWasInjectedImage = false;
-  const content = last.content;
   while (firstNonMemory < content.length) {
     const block = content[firstNonMemory];
     if (
@@ -576,23 +606,53 @@ export function stripExistingMemoryInjections(messages: Message[]): Message[] {
       block.text === "</memory_image>" &&
       prevWasInjectedImage
     ) {
-      // Closing tag from the 3-block pattern — only strip after an injected image
       firstNonMemory++;
       prevWasInjectedImage = false;
     } else {
       break;
     }
   }
+  return firstNonMemory;
+}
+
+/**
+ * Remove all memory-injected blocks from the last user message.
+ *
+ * `injectMemoryBlock` always prepends blocks in this order:
+ *   1. For each image: `<memory_image __injected>…` text + `image` + `</memory_image>` text (3-block group)
+ *   2. `<memory __injected>…</memory>` text block
+ *
+ * We strip all leading blocks that match this pattern so that
+ * `reinjectCachedMemory` is idempotent — no duplicate images after compaction.
+ */
+export function stripExistingMemoryInjections(messages: Message[]): Message[] {
+  if (messages.length === 0) return messages;
+  const last = messages[messages.length - 1];
+  if (!last || last.role !== "user") return messages;
 
-  // Nothing to strip
+  const firstNonMemory = countMemoryPrefixBlocks(last.content);
   if (firstNonMemory === 0) return messages;
 
   return [
     ...messages.slice(0, -1),
-    { ...last, content: content.slice(firstNonMemory) },
+    { ...last, content: last.content.slice(firstNonMemory) },
   ];
 }
 
+/**
+ * Return the memory-injected prefix blocks from the last user message, or
+ * an empty array when there is none. Used by runtime assembly to carry the
+ * memory block through transcript replacements (e.g. Slack chronological
+ * rendering) that otherwise discard the prepended content.
+ */
+export function extractMemoryPrefixBlocks(messages: Message[]): ContentBlock[] {
+  if (messages.length === 0) return [];
+  const last = messages[messages.length - 1];
+  if (!last || last.role !== "user") return [];
+  const count = countMemoryPrefixBlocks(last.content);
+  return count === 0 ? [] : last.content.slice(0, count);
+}
+
 function injectTextBlock(messages: Message[], text: string): Message[] {
   if (text.trim().length === 0) return messages;
   if (messages.length === 0) return messages;

package/src/memory/graph/extraction.test.ts

@@ -458,6 +458,221 @@ describe("parseExtractionResponse — edges", () => {
     expect(diff.createEdges).toHaveLength(0);
   });
 
+  test("new_edges resolves temp_ids to new→new deferred edges", () => {
+    const { diff, deferredEdges } = parse({
+      create_nodes: [
+        {
+          temp_id: "new-1",
+          content: "First beat.",
+          type: "episodic",
+          emotional_charge: {
+            valence: 0,
+            intensity: 0,
+            decay_curve: "linear",
+            decay_rate: 0.05,
+          },
+          significance: 0.5,
+          confidence: 0.8,
+          source_type: "direct",
+        },
+        {
+          temp_id: "new-2",
+          content: "Second beat.",
+          type: "episodic",
+          emotional_charge: {
+            valence: 0,
+            intensity: 0,
+            decay_curve: "linear",
+            decay_rate: 0.05,
+          },
+          significance: 0.5,
+          confidence: 0.8,
+          source_type: "direct",
+        },
+      ],
+      reinforce_node_ids: [],
+      new_edges: [
+        {
+          source_node_id: "new-1",
+          target_node_id: "new-2",
+          relationship: "part-of",
+          weight: 0.6,
+        },
+      ],
+    });
+
+    expect(diff.createEdges).toHaveLength(0);
+    expect(deferredEdges).toHaveLength(1);
+    expect(deferredEdges[0].source).toEqual({ kind: "new", newNodeIndex: 0 });
+    expect(deferredEdges[0].target).toEqual({ kind: "new", newNodeIndex: 1 });
+    expect(deferredEdges[0].relationship).toBe("part-of");
+  });
+
+  test("new_edges resolves existing→new via temp_id", () => {
+    const { diff, deferredEdges } = parse(
+      {
+        create_nodes: [
+          {
+            temp_id: "n1",
+            content: "A new memory linked from an old one.",
+            type: "episodic",
+            emotional_charge: {
+              valence: 0,
+              intensity: 0,
+              decay_curve: "linear",
+              decay_rate: 0.05,
+            },
+            significance: 0.5,
+            confidence: 0.8,
+            source_type: "direct",
+          },
+        ],
+        reinforce_node_ids: [],
+        new_edges: [
+          {
+            source_node_id: "existing-1",
+            target_node_id: "n1",
+            relationship: "reminds-of",
+          },
+        ],
+      },
+      ["existing-1"],
+    );
+
+    expect(diff.createEdges).toHaveLength(0);
+    expect(deferredEdges).toHaveLength(1);
+    expect(deferredEdges[0].source).toEqual({
+      kind: "existing",
+      nodeId: "existing-1",
+    });
+    expect(deferredEdges[0].target).toEqual({ kind: "new", newNodeIndex: 0 });
+  });
+
+  test("new_edges with two existing endpoints lands in diff.createEdges", () => {
+    const { diff, deferredEdges } = parse(
+      {
+        create_nodes: [],
+        reinforce_node_ids: [],
+        new_edges: [
+          {
+            source_node_id: "a",
+            target_node_id: "b",
+            relationship: "depends-on",
+            weight: 0.5,
+          },
+        ],
+      },
+      ["a", "b"],
+    );
+
+    expect(diff.createEdges).toHaveLength(1);
+    expect(diff.createEdges[0].sourceNodeId).toBe("a");
+    expect(diff.createEdges[0].targetNodeId).toBe("b");
+    expect(deferredEdges).toHaveLength(0);
+  });
+
+  test("new_edges skips references to unknown temp_ids", () => {
+    const { diff, deferredEdges } = parse(
+      {
+        create_nodes: [
+          {
+            temp_id: "n1",
+            content: "Something.",
+            type: "semantic",
+            emotional_charge: {
+              valence: 0,
+              intensity: 0,
+              decay_curve: "linear",
+              decay_rate: 0.05,
+            },
+            significance: 0.5,
+            confidence: 0.8,
+            source_type: "direct",
+          },
+        ],
+        reinforce_node_ids: [],
+        new_edges: [
+          {
+            source_node_id: "n1",
+            target_node_id: "n-does-not-exist",
+            relationship: "caused-by",
+          },
+        ],
+      },
+      [],
+    );
+
+    expect(diff.createEdges).toHaveLength(0);
+    expect(deferredEdges).toHaveLength(0);
+  });
+
+  test("candidate ID takes precedence over colliding temp_id", () => {
+    const { diff, deferredEdges } = parse(
+      {
+        create_nodes: [
+          {
+            temp_id: "collide",
+            content: "New node.",
+            type: "semantic",
+            emotional_charge: {
+              valence: 0,
+              intensity: 0,
+              decay_curve: "linear",
+              decay_rate: 0.05,
+            },
+            significance: 0.5,
+            confidence: 0.8,
+            source_type: "direct",
+          },
+        ],
+        reinforce_node_ids: [],
+        new_edges: [
+          {
+            source_node_id: "other",
+            target_node_id: "collide",
+            relationship: "reminds-of",
+          },
+        ],
+      },
+      ["collide", "other"],
+    );
+
+    // "collide" resolves to the existing candidate, not the new node's temp_id.
+    expect(diff.createEdges).toHaveLength(1);
+    expect(diff.createEdges[0].targetNodeId).toBe("collide");
+    expect(deferredEdges).toHaveLength(0);
+  });
+
+  test("edges_to_existing self-loop (same-node temp_id) is dropped", () => {
+    const { deferredEdges, diff } = parse({
+      create_nodes: [
+        {
+          temp_id: "n1",
+          content: "Self-referential.",
+          type: "semantic",
+          emotional_charge: {
+            valence: 0,
+            intensity: 0,
+            decay_curve: "linear",
+            decay_rate: 0.05,
+          },
+          significance: 0.5,
+          confidence: 0.8,
+          source_type: "direct",
+          edges_to_existing: [
+            {
+              target_node_id: "n1",
+              relationship: "part-of",
+            },
+          ],
+        },
+      ],
+      reinforce_node_ids: [],
+    });
+    expect(diff.createNodes).toHaveLength(1);
+    expect(deferredEdges).toHaveLength(0);
+  });
+
   test("defaults edge weight to 1.0", () => {
     const { diff } = parse(
       {
@@ -512,12 +727,67 @@ describe("parseExtractionResponse — deferred edges", () => {
       ["existing-1"],
     );
     expect(deferredEdges).toHaveLength(1);
-    expect(deferredEdges[0].newNodeIndex).toBe(0);
-    expect(deferredEdges[0].targetNodeId).toBe("existing-1");
+    expect(deferredEdges[0].source).toEqual({ kind: "new", newNodeIndex: 0 });
+    expect(deferredEdges[0].target).toEqual({
+      kind: "existing",
+      nodeId: "existing-1",
+    });
     expect(deferredEdges[0].relationship).toBe("caused-by");
     expect(deferredEdges[0].weight).toBe(0.7);
   });
 
+  test("resolves new→new edges in edges_to_existing via temp_ids", () => {
+    const { deferredEdges, diff } = parse({
+      create_nodes: [
+        {
+          temp_id: "n1",
+          content: "Event A happened.",
+          type: "episodic",
+          emotional_charge: {
+            valence: 0,
+            intensity: 0,
+            decay_curve: "linear",
+            decay_rate: 0.05,
+          },
+          significance: 0.5,
+          confidence: 0.8,
+          source_type: "direct",
+          edges_to_existing: [
+            {
+              target_node_id: "n2",
+              relationship: "caused-by",
+              weight: 0.9,
+            },
+          ],
+        },
+        {
+          temp_id: "n2",
+          content: "Event B happened as a result.",
+          type: "episodic",
+          emotional_charge: {
+            valence: 0,
+            intensity: 0,
+            decay_curve: "linear",
+            decay_rate: 0.05,
+          },
+          significance: 0.5,
+          confidence: 0.8,
+          source_type: "direct",
+        },
+      ],
+      reinforce_node_ids: [],
+    });
+
+    expect(diff.createNodes).toHaveLength(2);
+    // Edge should NOT land in diff.createEdges (both endpoints are new).
+    expect(diff.createEdges).toHaveLength(0);
+    expect(deferredEdges).toHaveLength(1);
+    expect(deferredEdges[0].source).toEqual({ kind: "new", newNodeIndex: 0 });
+    expect(deferredEdges[0].target).toEqual({ kind: "new", newNodeIndex: 1 });
+    expect(deferredEdges[0].relationship).toBe("caused-by");
+    expect(deferredEdges[0].weight).toBe(0.9);
+  });
+
   test("ignores deferred edges to non-candidate targets", () => {
     const { deferredEdges } = parse(
       {