@vellumai/assistant 0.8.1 → 0.8.3

package/src/memory/delivery-crud.ts

@@ -5,11 +5,17 @@
  * finding messages by source identifiers, and managing raw payload storage.
  */
 
-import { and, eq, isNotNull } from "drizzle-orm";
+import { and, eq, isNotNull, or } from "drizzle-orm";
 import { v4 as uuid } from "uuid";
 
+import { readSlackMetadataFromMessageMetadata } from "../messaging/providers/slack/message-metadata.js";
 import { DAEMON_INTERNAL_ASSISTANT_ID } from "../runtime/assistant-scope.js";
-import { getOrCreateConversation } from "./conversation-key-store.js";
+import { selectSlackMetaCandidateMetadata } from "./conversation-crud.js";
+import {
+  getConversationByKey,
+  getOrCreateConversation,
+  setConversationKeyIfAbsent,
+} from "./conversation-key-store.js";
 import { getDb } from "./db-connection.js";
 import { channelInboundEvents, conversations } from "./schema.js";
 
@@ -23,6 +29,144 @@ export interface InboundResult {
 export interface RecordInboundOptions {
   sourceMessageId?: string;
   assistantId?: string;
+  sourceThreadId?: string;
+}
+
+const SLACK_LEGACY_THREAD_EVIDENCE_BATCH_SIZE = 50;
+const SLACK_LEGACY_THREAD_EVIDENCE_MAX_SCAN = 500;
+
+function buildScopedConversationKeyForAssistant(
+  assistantId: string,
+  sourceChannel: string,
+  externalChatId: string,
+  sourceThreadId?: string | null,
+): string {
+  const threadId = sourceThreadId?.trim();
+  if (sourceChannel === "slack" && threadId) {
+    return `asst:${assistantId}:${sourceChannel}:${externalChatId}:thread:${threadId}`;
+  }
+  return `asst:${assistantId}:${sourceChannel}:${externalChatId}`;
+}
+
+export function buildScopedConversationKey(
+  sourceChannel: string,
+  externalChatId: string,
+  sourceThreadId?: string | null,
+): string {
+  return buildScopedConversationKeyForAssistant(
+    DAEMON_INTERNAL_ASSISTANT_ID,
+    sourceChannel,
+    externalChatId,
+    sourceThreadId,
+  );
+}
+
+function legacySlackConversationHasThreadEvidence(
+  conversationId: string,
+  externalChatId: string,
+  sourceThreadId: string,
+): boolean {
+  const db = getDb();
+  const inboundEvidence = db
+    .select({ id: channelInboundEvents.id })
+    .from(channelInboundEvents)
+    .where(
+      and(
+        eq(channelInboundEvents.conversationId, conversationId),
+        eq(channelInboundEvents.sourceChannel, "slack"),
+        eq(channelInboundEvents.externalChatId, externalChatId),
+        or(
+          eq(channelInboundEvents.sourceMessageId, sourceThreadId),
+          eq(channelInboundEvents.externalMessageId, sourceThreadId),
+        ),
+      ),
+    )
+    .get();
+
+  if (inboundEvidence) {
+    return true;
+  }
+
+  let offset = 0;
+  while (offset < SLACK_LEGACY_THREAD_EVIDENCE_MAX_SCAN) {
+    const remaining = SLACK_LEGACY_THREAD_EVIDENCE_MAX_SCAN - offset;
+    const batchLimit = Math.min(
+      SLACK_LEGACY_THREAD_EVIDENCE_BATCH_SIZE,
+      remaining,
+    );
+    const metadataRows = selectSlackMetaCandidateMetadata(
+      conversationId,
+      batchLimit,
+      offset,
+      { includeFlatLegacy: true },
+    );
+
+    if (metadataRows.length === 0) return false;
+    for (const metadata of metadataRows) {
+      const slackMeta = readSlackMetadataFromMessageMetadata(metadata, {
+        allowFlatLegacy: true,
+      });
+      if (
+        slackMeta?.channelId === externalChatId &&
+        slackMeta.threadTs === sourceThreadId
+      ) {
+        return true;
+      }
+    }
+
+    if (metadataRows.length < batchLimit) return false;
+    offset += metadataRows.length;
+  }
+
+  return false;
+}
+
+function resolveInboundConversation(
+  assistantId: string,
+  sourceChannel: string,
+  externalChatId: string,
+  sourceThreadId?: string | null,
+): { conversationId: string } {
+  const threadedKey = buildScopedConversationKeyForAssistant(
+    assistantId,
+    sourceChannel,
+    externalChatId,
+    sourceThreadId,
+  );
+
+  const threadId = sourceThreadId?.trim();
+  if (sourceChannel !== "slack" || !threadId) {
+    return getOrCreateConversation(threadedKey);
+  }
+
+  const threadedMapping = getConversationByKey(threadedKey);
+  if (threadedMapping) {
+    return { conversationId: threadedMapping.conversationId };
+  }
+
+  const legacyKey = buildScopedConversationKeyForAssistant(
+    assistantId,
+    sourceChannel,
+    externalChatId,
+    null,
+  );
+  const legacyMapping = getConversationByKey(legacyKey);
+  if (
+    legacyMapping &&
+    legacySlackConversationHasThreadEvidence(
+      legacyMapping.conversationId,
+      externalChatId,
+      threadId,
+    )
+  ) {
+    setConversationKeyIfAbsent(threadedKey, legacyMapping.conversationId);
+    const aliasedMapping = getConversationByKey(threadedKey);
+    if (aliasedMapping) {
+      return { conversationId: aliasedMapping.conversationId };
+    }
+  }
+
+  return getOrCreateConversation(threadedKey);
 }
 
 /**
@@ -62,8 +206,12 @@ export function recordInbound(
   }
 
   const assistantId = options?.assistantId ?? DAEMON_INTERNAL_ASSISTANT_ID;
-  const scopedKey = `asst:${assistantId}:${sourceChannel}:${externalChatId}`;
-  const mapping = getOrCreateConversation(scopedKey);
+  const mapping = resolveInboundConversation(
+    assistantId,
+    sourceChannel,
+    externalChatId,
+    options?.sourceThreadId,
+  );
   const now = Date.now();
   const eventId = uuid();
 
@@ -176,4 +324,3 @@ export function clearPayload(eventId: string): void {
     .where(eq(channelInboundEvents.id, eventId))
     .run();
 }
-

package/src/memory/embedding-backend.ts

@@ -4,8 +4,8 @@ import { isAssistantFeatureFlagEnabled } from "../config/assistant-feature-flags
 import { getOllamaBaseUrlEnv } from "../config/env.js";
 import { resolveCallSiteConfig } from "../config/llm-resolver.js";
 import type { AssistantConfig } from "../config/types.js";
-import { MANAGED_PROVIDER_META } from "../providers/managed-proxy/constants.js";
-import { resolveManagedProxyContext } from "../providers/managed-proxy/context.js";
+import { PLATFORM_PROVIDER_META } from "../providers/platform-proxy/constants.js";
+import { resolveManagedProxyContext } from "../providers/platform-proxy/context.js";
 import { getProviderKeyAsync } from "../security/secure-keys.js";
 import { getLogger } from "../util/logger.js";
 import { GeminiEmbeddingBackend } from "./embedding-gemini.js";
@@ -311,7 +311,7 @@ export async function selectEmbeddingBackend(
   ) {
     const proxyCtx = await resolveManagedProxyContext();
     if (proxyCtx.enabled) {
-      const meta = MANAGED_PROVIDER_META["gemini"];
+      const meta = PLATFORM_PROVIDER_META["gemini"];
       if (meta?.managed && meta.proxyPath) {
         const managedBaseUrl = `${proxyCtx.platformBaseUrl}${meta.proxyPath}`;
         const managedModel = config.memory.embeddings.geminiModel;
@@ -685,7 +685,7 @@ async function selectFallbackBackends(
         ) {
           // Try managed proxy Gemini as fallback when no direct key exists.
           const proxyCtx = await resolveManagedProxyContext();
-          const meta = MANAGED_PROVIDER_META["gemini"];
+          const meta = PLATFORM_PROVIDER_META["gemini"];
           if (proxyCtx.enabled && meta?.managed && meta.proxyPath) {
             const managedBaseUrl = `${proxyCtx.platformBaseUrl}${meta.proxyPath}`;
             const managedModel = config.memory.embeddings.geminiModel;

package/src/memory/external-conversation-store.ts

@@ -7,7 +7,7 @@
  * list APIs.
  */
 
-import { and, eq, inArray } from "drizzle-orm";
+import { and, eq, inArray, isNull } from "drizzle-orm";
 
 import { getDb } from "./db-connection.js";
 import { externalConversationBindings } from "./schema.js";
@@ -16,6 +16,7 @@ export interface ExternalConversationBinding {
   conversationId: string;
   sourceChannel: string;
   externalChatId: string;
+  externalThreadId?: string | null;
   externalUserId?: string | null;
   displayName?: string | null;
   username?: string | null;
@@ -29,11 +30,19 @@ export interface UpsertBindingInput {
   conversationId: string;
   sourceChannel: string;
   externalChatId: string;
+  externalThreadId?: string | null;
   externalUserId?: string | null;
   displayName?: string | null;
   username?: string | null;
 }
 
+function normalizeExternalThreadId(
+  externalThreadId?: string | null,
+): string | null {
+  const trimmed = externalThreadId?.trim();
+  return trimmed ? trimmed : null;
+}
+
 /**
  * Insert or update an external conversation binding on conflict (conversationId).
  * On conflict, updates channel metadata and timestamps.
@@ -41,12 +50,14 @@ export interface UpsertBindingInput {
 export function upsertBinding(input: UpsertBindingInput): void {
   const db = getDb();
   const now = Date.now();
+  const externalThreadId = normalizeExternalThreadId(input.externalThreadId);
 
-  // If a stale binding exists for this (sourceChannel, externalChatId) under a
+  // If a stale binding exists for this channel/chat/thread tuple under a
   // different conversationId, remove it first so the unique index is not violated.
-  const existing = getBindingByChannelChat(
+  const existing = getBindingByChannelChatThread(
     input.sourceChannel,
     input.externalChatId,
+    externalThreadId,
   );
   if (existing && existing.conversationId !== input.conversationId) {
     db.delete(externalConversationBindings)
@@ -64,6 +75,7 @@ export function upsertBinding(input: UpsertBindingInput): void {
       conversationId: input.conversationId,
       sourceChannel: input.sourceChannel,
       externalChatId: input.externalChatId,
+      externalThreadId,
       externalUserId: input.externalUserId ?? null,
       displayName: input.displayName ?? null,
       username: input.username ?? null,
@@ -76,6 +88,7 @@ export function upsertBinding(input: UpsertBindingInput): void {
       set: {
         sourceChannel: input.sourceChannel,
         externalChatId: input.externalChatId,
+        externalThreadId,
         externalUserId: input.externalUserId ?? null,
         displayName: input.displayName ?? null,
         username: input.username ?? null,
@@ -95,15 +108,18 @@ export function upsertOutboundBinding(input: {
   conversationId: string;
   sourceChannel: string;
   externalChatId: string;
+  externalThreadId?: string | null;
 }): void {
   const db = getDb();
   const now = Date.now();
+  const externalThreadId = normalizeExternalThreadId(input.externalThreadId);
 
-  // If a stale binding exists for this (sourceChannel, externalChatId) under a
+  // If a stale binding exists for this channel/chat/thread tuple under a
   // different conversationId, remove it first so the unique index is not violated.
-  const existing = getBindingByChannelChat(
+  const existing = getBindingByChannelChatThread(
     input.sourceChannel,
     input.externalChatId,
+    externalThreadId,
   );
   if (existing && existing.conversationId !== input.conversationId) {
     db.delete(externalConversationBindings)
@@ -121,6 +137,7 @@ export function upsertOutboundBinding(input: {
       conversationId: input.conversationId,
       sourceChannel: input.sourceChannel,
       externalChatId: input.externalChatId,
+      externalThreadId,
       externalUserId: null,
       displayName: null,
       username: null,
@@ -133,6 +150,7 @@ export function upsertOutboundBinding(input: {
       set: {
         sourceChannel: input.sourceChannel,
         externalChatId: input.externalChatId,
+        externalThreadId,
         updatedAt: now,
         lastOutboundAt: now,
       },
@@ -161,8 +179,20 @@ export function getBindingByConversation(
 export function getBindingByChannelChat(
   sourceChannel: string,
   externalChatId: string,
+): ExternalConversationBinding | null {
+  return getBindingByChannelChatThread(sourceChannel, externalChatId, null);
+}
+
+/**
+ * Look up an external binding by channel + external chat ID + optional thread ID.
+ */
+export function getBindingByChannelChatThread(
+  sourceChannel: string,
+  externalChatId: string,
+  externalThreadId?: string | null,
 ): ExternalConversationBinding | null {
   const db = getDb();
+  const normalizedThreadId = normalizeExternalThreadId(externalThreadId);
   const row = db
     .select()
     .from(externalConversationBindings)
@@ -170,6 +200,12 @@ export function getBindingByChannelChat(
       and(
         eq(externalConversationBindings.sourceChannel, sourceChannel),
         eq(externalConversationBindings.externalChatId, externalChatId),
+        normalizedThreadId
+          ? eq(
+              externalConversationBindings.externalThreadId,
+              normalizedThreadId,
+            )
+          : isNull(externalConversationBindings.externalThreadId),
       ),
     )
     .get();
@@ -195,6 +231,31 @@ export function deleteBindingByChannelChat(
     .run();
 }
 
+/**
+ * Remove an external binding by channel + external chat ID + thread ID.
+ */
+export function deleteBindingByChannelChatThread(
+  sourceChannel: string,
+  externalChatId: string,
+  externalThreadId: string,
+): void {
+  const db = getDb();
+  const normalizedThreadId = normalizeExternalThreadId(externalThreadId);
+  if (!normalizedThreadId) {
+    deleteBindingByChannelChat(sourceChannel, externalChatId);
+    return;
+  }
+  db.delete(externalConversationBindings)
+    .where(
+      and(
+        eq(externalConversationBindings.sourceChannel, sourceChannel),
+        eq(externalConversationBindings.externalChatId, externalChatId),
+        eq(externalConversationBindings.externalThreadId, normalizedThreadId),
+      ),
+    )
+    .run();
+}
+
 /**
  * Get bindings for multiple conversation IDs at once.
  * Returns a map of conversationId -> binding for efficient lookup.

package/src/memory/graph/__tests__/conversation-graph-memory-v2-routing.test.ts

@@ -107,18 +107,20 @@ mock.module("@qdrant/js-client-rest", () => ({
   QdrantClient: MockQdrantClient,
 }));
 
+const embedWithBackendMock = mock(async (_config, texts: string[]) => ({
+  provider: "local",
+  model: "test-model",
+  vectors: texts.map(() => [0.1, 0.2, 0.3]) as number[][],
+}));
+const generateSparseEmbeddingMock = mock((_text: string) => ({
+  indices: [1, 2, 3],
+  values: [0.5, 0.5, 0.5] as number[],
+}));
 const realEmbeddingBackend = await import("../../embedding-backend.js");
 mock.module("../../embedding-backend.js", () => ({
   ...realEmbeddingBackend,
-  embedWithBackend: async () => ({
-    provider: "local",
-    model: "test-model",
-    vectors: [[0.1, 0.2, 0.3]] as number[][],
-  }),
-  generateSparseEmbedding: () => ({
-    indices: [1, 2, 3],
-    values: [0.5, 0.5, 0.5] as number[],
-  }),
+  embedWithBackend: embedWithBackendMock,
+  generateSparseEmbedding: generateSparseEmbeddingMock,
 }));
 
 const realQdrantClient = await import("../../qdrant-client.js");
@@ -175,7 +177,7 @@ const { migrateActivationState } =
   await import("../../migrations/232-activation-state.js");
 const schema = await import("../../schema.js");
 const { _resetMemoryV2QdrantForTests } = await import("../../v2/qdrant.js");
-const { hydrate: hydrateActivationState } =
+const { hydrate: hydrateActivationState, save: saveActivationState } =
   await import("../../v2/activation-store.js");
 
 // The wiring layer calls `getDb()` to fetch the SQLite handle. We mock
@@ -213,9 +215,14 @@ function createTestDb(): DrizzleDb {
   return db;
 }
 
-function makeConfig(v2Enabled: boolean): AssistantConfig {
+function makeConfig(v2Enabled: boolean, memoryEnabled = true): AssistantConfig {
+  // Pin `router.enabled: false` so these tests exercise the activation
+  // pipeline. Router-mode coverage lives in `memory/v2/__tests__/injection.test.ts`.
   return applyNestedDefaults({
-    memory: { v2: { enabled: v2Enabled } },
+    memory: {
+      enabled: memoryEnabled,
+      v2: { enabled: v2Enabled, router: { enabled: false } },
+    },
   }) as AssistantConfig;
 }
 
@@ -293,6 +300,8 @@ beforeEach(() => {
   qdrantState.queryResponses.sparse.length = 0;
   loadContextMemoryMock.mockClear();
   retrieveForTurnMock.mockClear();
+  embedWithBackendMock.mockClear();
+  generateSparseEmbeddingMock.mockClear();
   _resetMemoryV2QdrantForTests();
 });
 
@@ -390,6 +399,59 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (per-turn path)",
     expect(firstBlock.text).toContain("# memory/concepts/alice-vscode.md");
   });
 
+  test("per-turn dense embedding is computed from combined assistant+user text", async () => {
+    // Short referential follow-ups ("do that one") carry no semantic signal
+    // on their own — the dense PKB query embedding must mirror v1's
+    // `retrieveForTurn` and combine the prior assistant turn so hint search
+    // still resolves what "that one" refers to. The sparse vector matches
+    // v1 by using the user message alone so lexical signal isn't diluted.
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true);
+    const assistantText =
+      "Alice prefers VS Code as her editor — she finds the extension ecosystem unmatched.";
+    const userText = "do that one";
+    const messages: Message[] = [
+      {
+        role: "user",
+        content: [
+          { type: "text" as const, text: "what editors did we cover?" },
+        ],
+      },
+      {
+        role: "assistant",
+        content: [{ type: "text" as const, text: assistantText }],
+      },
+      { role: "user", content: [{ type: "text" as const, text: userText }] },
+    ];
+
+    await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    // v1's `retrieveForTurn` joins assistantLast + userLast with "\n\n" and
+    // embeds the combined string as the dense query vector. Assert the v2
+    // path makes the exact same embed call somewhere during this turn.
+    const expectedCombined = `${assistantText}\n\n${userText}`;
+    const matchingCall = embedWithBackendMock.mock.calls.find((call) => {
+      const texts = call[1] as string[];
+      return texts.length === 1 && texts[0] === expectedCombined;
+    });
+    expect(matchingCall).toBeDefined();
+
+    // Sparse embedding for the per-turn query uses userLast only.
+    expect(generateSparseEmbeddingMock.mock.calls).toContainEqual([userText]);
+    expect(
+      generateSparseEmbeddingMock.mock.calls.some((call) =>
+        (call[0] as string).includes(assistantText),
+      ),
+    ).toBe(false);
+  });
+
   test("config on with empty Qdrant hits → no v2 block, v1 fallback skipped", async () => {
     // No `stageTurn` call — every channel returns `{ points: [] }` so the
     // candidate set is empty and `injectMemoryV2Block` returns block=null.
@@ -461,6 +523,50 @@ describe("ConversationGraphMemory.prepareMemory — v2 routing (context-load pat
   });
 });
 
+describe("ConversationGraphMemory.prepareMemory — memory.enabled gate", () => {
+  test("memory.enabled=false short-circuits per-turn path: mode=none, no injection, v2/v1 not called", async () => {
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = makeMemory();
+    const config = makeConfig(true, false);
+    const messages = makeMessages();
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("none");
+    expect(result.injectedBlockText).toBeNull();
+    expect(result.runMessages).toEqual(messages);
+    expect(retrieveForTurnMock).not.toHaveBeenCalled();
+    expect(loadContextMemoryMock).not.toHaveBeenCalled();
+  });
+
+  test("memory.enabled=false short-circuits context-load path: mode=none, no injection, v2/v1 not called", async () => {
+    stageTurn([{ slug: "alice-vscode", denseScore: 0.9 }]);
+
+    const memory = new ConversationGraphMemory("conv-test-master-off");
+    const config = makeConfig(true, false);
+    const messages = makeMessages("first message of the conversation here");
+
+    const result = await memory.prepareMemory(
+      messages,
+      config,
+      new AbortController().signal,
+      noopEvent,
+    );
+
+    expect(result.mode).toBe("none");
+    expect(result.injectedBlockText).toBeNull();
+    expect(result.runMessages).toEqual(messages);
+    expect(loadContextMemoryMock).not.toHaveBeenCalled();
+    expect(retrieveForTurnMock).not.toHaveBeenCalled();
+  });
+});
+
 describe("ConversationGraphMemory.onCompacted — v2 activation eviction", () => {
   test("clears everInjected so a previously-injected slug can re-attach", async () => {
     // Without this wiring, `selectInjections` keeps subtracting the slug from
@@ -504,4 +610,36 @@ describe("ConversationGraphMemory.onCompacted — v2 activation eviction", () =>
       "# memory/concepts/alice-vscode.md",
     );
   });
+
+  test("clears everInjected entries whose turn exceeds the tracker's currentTurn (zombie drift)", async () => {
+    // Regression: under the prior turn-bounded eviction, entries with `turn >
+    // tracker.currentTurn` survived `onCompacted` forever. This can happen
+    // after a non-graceful shutdown: `everInjected` is persisted every turn
+    // while the tracker snapshot is only persisted on graceful dispose, so a
+    // SIGKILL'd session followed by a reload restores the tracker from an
+    // older snapshot with a lower currentTurn while keeping the high-turn
+    // entries on disk.
+    const conversationId = "conv-test-zombie-drift";
+    const memory = new ConversationGraphMemory(conversationId);
+
+    // Seed the simulated post-crash state directly: tracker stays at
+    // currentTurn=0 (default for a fresh ConversationGraphMemory), while the
+    // persisted row carries everInjected entries from turns 10 and 20 (left
+    // over from a prior session that never disposed cleanly).
+    await saveActivationState(testDbHandle!, conversationId, {
+      messageId: "msg-zombie",
+      state: {},
+      everInjected: [
+        { slug: "alice-vscode", turn: 10 },
+        { slug: "bob-pkg-mgr", turn: 20 },
+      ],
+      currentTurn: 0,
+      updatedAt: 1,
+    });
+
+    await memory.onCompacted(0);
+
+    const after = await hydrateActivationState(testDbHandle!, conversationId);
+    expect(after?.everInjected).toEqual([]);
+  });
 });