@vellumai/assistant 0.7.0 → 0.7.1

package/src/__tests__/cu-unified-flow.test.ts

@@ -5,11 +5,32 @@
  * point between the agent loop and the HostCuProxy.
  */
 
-import { afterEach, describe, expect, test } from "bun:test";
-
-import type { SurfaceConversationContext } from "../daemon/conversation-surfaces.js";
-import { surfaceProxyResolver } from "../daemon/conversation-surfaces.js";
-import { HostCuProxy } from "../daemon/host-cu-proxy.js";
+import { afterEach, describe, expect, mock, test } from "bun:test";
+
+const sentMessages: unknown[] = [];
+let mockHasClient = true; // Default to true for CU unified flow tests
+
+mock.module("../runtime/assistant-event-hub.js", () => ({
+  broadcastMessage: (msg: unknown) => sentMessages.push(msg),
+  assistantEventHub: {
+    getMostRecentClientByCapability: (cap: string) =>
+      cap === "host_cu" && mockHasClient ? { id: "mock-client" } : null,
+  },
+}));
+
+mock.module("../runtime/pending-interactions.js", () => ({
+  resolve: () => undefined,
+  get: () => undefined,
+  getByKind: () => [],
+  getByConversation: () => [],
+  removeByConversation: () => {},
+}));
+
+const { surfaceProxyResolver } = await import(
+  "../daemon/conversation-surfaces.js"
+);
+const { HostCuProxy } = await import("../daemon/host-cu-proxy.js");
+type SurfaceConversationContext = import("../daemon/conversation-surfaces.js").SurfaceConversationContext;
 
 // ---------------------------------------------------------------------------
 // Test helpers
@@ -20,7 +41,7 @@ import { HostCuProxy } from "../daemon/host-cu-proxy.js";
  * Only the fields required by the CU routing path are populated.
  */
 function buildMockContext(
-  hostCuProxy?: HostCuProxy,
+  hostCuProxy?: InstanceType<typeof HostCuProxy>,
 ): SurfaceConversationContext {
   return {
     conversationId: "test-session",
@@ -47,15 +68,12 @@ function buildMockContext(
 // ---------------------------------------------------------------------------
 
 describe("surfaceProxyResolver — CU tool routing", () => {
-  let sentMessages: unknown[];
-  let proxy: HostCuProxy;
+  let proxy: InstanceType<typeof HostCuProxy>;
 
   function setupProxy(maxSteps?: number): SurfaceConversationContext {
-    sentMessages = [];
-    const sendToClient = (msg: unknown) => sentMessages.push(msg);
-    proxy = new HostCuProxy(sendToClient as never, undefined, maxSteps);
-    // Mark client as connected so requests are sent
-    proxy.updateSender(sendToClient as never, true);
+    sentMessages.length = 0;
+    mockHasClient = true;
+    proxy = new HostCuProxy(maxSteps);
     return buildMockContext(proxy);
   }
 
@@ -93,9 +111,8 @@ describe("surfaceProxyResolver — CU tool routing", () => {
     });
 
     test("returns error when proxy exists but client not connected", async () => {
-      const sendToClient = () => {};
-      const proxyObj = new HostCuProxy(sendToClient as never);
-      // Default clientConnected is false — do NOT call updateSender with true
+      mockHasClient = false;
+      const proxyObj = new HostCuProxy();
       const ctx = buildMockContext(proxyObj);
       const result = await surfaceProxyResolver(ctx, "computer_use_click", {
         element_id: 1,

package/src/__tests__/daemon-assistant-events.test.ts

@@ -33,11 +33,10 @@ describe("buildAssistantEvent", () => {
       conversationId: "sess_1",
       text: "hi",
     };
-    const event = buildAssistantEvent("ast_1", msg, "sess_1");
+    const event = buildAssistantEvent(msg, "sess_1");
 
     expect(typeof event.id).toBe("string");
     expect(event.id.length).toBeGreaterThan(0);
-    expect(event.assistantId).toBe("ast_1");
     expect(event.conversationId).toBe("sess_1");
     expect(event.message).toBe(msg);
     expect(typeof event.emittedAt).toBe("string");
@@ -46,14 +45,14 @@ describe("buildAssistantEvent", () => {
 
   test("generates unique ids for each call", () => {
     const msg: ServerMessage = { type: "pong" };
-    const a = buildAssistantEvent("ast", msg);
-    const b = buildAssistantEvent("ast", msg);
+    const a = buildAssistantEvent(msg);
+    const b = buildAssistantEvent(msg);
     expect(a.id).not.toBe(b.id);
   });
 
   test("conversationId is undefined when omitted", () => {
     const msg: ServerMessage = { type: "pong" };
-    const event = buildAssistantEvent("ast", msg);
+    const event = buildAssistantEvent(msg);
     expect(event.conversationId).toBeUndefined();
   });
 });
@@ -65,8 +64,11 @@ describe("daemon send → one mirrored assistant event", () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_test" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
 
     const msg: ServerMessage = {
@@ -74,11 +76,10 @@ describe("daemon send → one mirrored assistant event", () => {
       conversationId: "sess_a",
       text: "hello",
     };
-    const event = buildAssistantEvent("ast_test", msg, "sess_a");
+    const event = buildAssistantEvent(msg, "sess_a");
     await hub.publish(event);
 
     expect(received).toHaveLength(1);
-    expect(received[0].assistantId).toBe("ast_test");
     expect(received[0].conversationId).toBe("sess_a");
     expect(received[0].message.type).toBe("assistant_text_delta");
   });
@@ -87,12 +88,15 @@ describe("daemon send → one mirrored assistant event", () => {
     const hub = new AssistantEventHub();
     const received: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_test" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
 
     const msg: ServerMessage = { type: "pong" }; // no conversationId field
-    const event = buildAssistantEvent("ast_test", msg, "sess_explicit");
+    const event = buildAssistantEvent(msg, "sess_explicit");
 
     await hub.publish(event);
 
@@ -107,11 +111,17 @@ describe("daemon broadcast → one mirrored event per message (not per socket)",
     const received: AssistantEvent[] = [];
 
     // Two subscribers (simulating two wire clients)
-    hub.subscribe({ assistantId: "ast_bc" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
-    hub.subscribe({ assistantId: "ast_bc" }, (e) => {
-      received.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        received.push(e);
+      },
     });
 
     // Simulate broadcast: server calls publishAssistantEvent once
@@ -119,7 +129,7 @@ describe("daemon broadcast → one mirrored event per message (not per socket)",
       type: "message_complete",
       conversationId: "sess_b",
     };
-    const event = buildAssistantEvent("ast_bc", msg, "sess_b");
+    const event = buildAssistantEvent(msg, "sess_b");
     await hub.publish(event);
 
     // Both hub subscribers receive it (fanout), but only ONE event was published
@@ -130,8 +140,11 @@ describe("daemon broadcast → one mirrored event per message (not per socket)",
     const hub = new AssistantEventHub();
     const publishedEvents: AssistantEvent[] = [];
 
-    hub.subscribe({ assistantId: "ast_bc" }, (e) => {
-      publishedEvents.push(e);
+    hub.subscribe({
+      type: "process",
+      callback: (e) => {
+        publishedEvents.push(e);
+      },
     });
 
     const msgA: ServerMessage = {
@@ -145,8 +158,8 @@ describe("daemon broadcast → one mirrored event per message (not per socket)",
     };
 
     // Simulate: one broadcast + one single send
-    await hub.publish(buildAssistantEvent("ast_bc", msgA, "s1"));
-    await hub.publish(buildAssistantEvent("ast_bc", msgB, "s1"));
+    await hub.publish(buildAssistantEvent(msgA, "s1"));
+    await hub.publish(buildAssistantEvent(msgB, "s1"));
 
     expect(publishedEvents).toHaveLength(2);
     expect(publishedEvents[0].message.type).toBe("assistant_text_delta");

package/src/__tests__/daemon-credential-client.test.ts

@@ -21,6 +21,7 @@ mock.module("../util/logger.js", () => ({
 }));
 
 import { setSecureKeyViaDaemon } from "../cli/lib/daemon-credential-client.js";
+import { credentialKey } from "../security/credential-key.js";
 import { getSecureKeyAsync } from "../security/secure-keys.js";
 
 describe("daemon credential writes (daemon unreachable)", () => {
@@ -32,7 +33,9 @@ describe("daemon credential writes (daemon unreachable)", () => {
     );
     expect(result).toBe(true);
 
-    const readBack = await getSecureKeyAsync("test-provider");
+    const readBack = await getSecureKeyAsync(
+      credentialKey("test-provider", "api_key"),
+    );
     expect(readBack).toBe("test-value");
   });
 });

package/src/__tests__/db-connection-isolation.test.ts

@@ -0,0 +1,125 @@
+import {
+  mkdirSync,
+  mkdtempSync,
+  realpathSync,
+  rmSync,
+  symlinkSync,
+} from "node:fs";
+import { homedir, tmpdir } from "node:os";
+import { join } from "node:path";
+import { afterEach, expect, test } from "bun:test";
+
+import { getDb, resetDb } from "../memory/db-connection.js";
+
+const originalWorkspaceDir = process.env.VELLUM_WORKSPACE_DIR;
+const originalAllowRealWorkspace =
+  process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+const originalTestRealWorkspace = process.env.VELLUM_TEST_REAL_WORKSPACE_DIR;
+const originalHome = process.env.HOME;
+
+afterEach(() => {
+  resetDb();
+  if (originalWorkspaceDir === undefined) {
+    delete process.env.VELLUM_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_WORKSPACE_DIR = originalWorkspaceDir;
+  }
+
+  if (originalAllowRealWorkspace === undefined) {
+    delete process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+  } else {
+    process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS =
+      originalAllowRealWorkspace;
+  }
+
+  if (originalTestRealWorkspace === undefined) {
+    delete process.env.VELLUM_TEST_REAL_WORKSPACE_DIR;
+  } else {
+    process.env.VELLUM_TEST_REAL_WORKSPACE_DIR = originalTestRealWorkspace;
+  }
+
+  if (originalHome === undefined) {
+    delete process.env.HOME;
+  } else {
+    process.env.HOME = originalHome;
+  }
+});
+
+test("getDb refuses test runs without an isolated workspace", () => {
+  resetDb();
+  delete process.env.VELLUM_WORKSPACE_DIR;
+  delete process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+
+  expect(() => getDb()).toThrow(
+    "Refusing to open the assistant DB during tests without VELLUM_WORKSPACE_DIR",
+  );
+});
+
+test("getDb refuses the real workspace during tests even when explicitly set", () => {
+  resetDb();
+  process.env.VELLUM_WORKSPACE_DIR = join(homedir(), ".vellum", "workspace");
+  delete process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+
+  expect(() => getDb()).toThrow(
+    "Refusing to open the real assistant workspace DB during tests",
+  );
+});
+
+test("getDb refuses symlink aliases to the real workspace during tests", () => {
+  resetDb();
+  const testRoot = realpathSync(
+    mkdtempSync(join(tmpdir(), "vellum-db-isolation-")),
+  );
+
+  try {
+    const fakeHome = join(testRoot, "home");
+    const realWorkspace = join(fakeHome, ".vellum", "workspace");
+    const aliasParent = join(testRoot, "aliases");
+    const workspaceAlias = join(aliasParent, "workspace-link");
+
+    mkdirSync(realWorkspace, { recursive: true });
+    mkdirSync(aliasParent, { recursive: true });
+    symlinkSync(realWorkspace, workspaceAlias, "dir");
+
+    process.env.HOME = fakeHome;
+    process.env.VELLUM_WORKSPACE_DIR = workspaceAlias;
+    process.env.VELLUM_TEST_REAL_WORKSPACE_DIR = realWorkspace;
+    delete process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+
+    expect(() => getDb()).toThrow(
+      "Refusing to open the real assistant workspace DB during tests",
+    );
+  } finally {
+    rmSync(testRoot, { recursive: true, force: true });
+  }
+});
+
+test("getDb refuses missing children under symlink aliases to the real workspace", () => {
+  resetDb();
+  const testRoot = realpathSync(
+    mkdtempSync(join(tmpdir(), "vellum-db-isolation-")),
+  );
+
+  try {
+    const fakeHome = join(testRoot, "home");
+    const realWorkspace = join(fakeHome, ".vellum", "workspace");
+    const aliasParent = join(testRoot, "aliases");
+    const workspaceLink = join(aliasParent, "workspace-link");
+    const missingChild = join(workspaceLink, "new-test-workspace");
+
+    mkdirSync(realWorkspace, { recursive: true });
+    mkdirSync(aliasParent, { recursive: true });
+    symlinkSync(realWorkspace, workspaceLink, "dir");
+
+    process.env.HOME = fakeHome;
+    process.env.VELLUM_WORKSPACE_DIR = missingChild;
+    process.env.VELLUM_TEST_REAL_WORKSPACE_DIR = realWorkspace;
+    delete process.env.VELLUM_ALLOW_REAL_WORKSPACE_IN_TESTS;
+
+    expect(() => getDb()).toThrow(
+      "Refusing to open the real assistant workspace DB during tests",
+    );
+  } finally {
+    rmSync(testRoot, { recursive: true, force: true });
+  }
+});

package/src/__tests__/db-migration-rollback.test.ts

@@ -57,6 +57,7 @@ import { migrateRenameThreadStartersCheckpointsDown } from "../memory/migrations
 import { migrateBackfillAudioAttachmentMimeTypesDown } from "../memory/migrations/191-backfill-audio-attachment-mime-types.js";
 import {
   migrateJobDeferrals,
+  migrateLlmUsageAttribution,
   migrateMemoryEntityRelationDedup,
   migrateMemoryItemsFingerprintScopeUnique,
   migrateMemoryItemsScopeSaltedFingerprints,
@@ -1767,6 +1768,106 @@ describe("memory migration down() functions", () => {
     });
   });
 
+  describe("migrateLlmUsageAttribution", () => {
+    test("adds nullable attribution columns without rewriting existing usage rows", () => {
+      const db = createTestDb();
+      const raw = getRaw(db);
+
+      raw.exec(/*sql*/ `
+        CREATE TABLE llm_usage_events (
+          id TEXT PRIMARY KEY,
+          created_at INTEGER NOT NULL,
+          conversation_id TEXT,
+          run_id TEXT,
+          request_id TEXT,
+          actor TEXT NOT NULL,
+          provider TEXT NOT NULL,
+          model TEXT NOT NULL,
+          input_tokens INTEGER NOT NULL,
+          output_tokens INTEGER NOT NULL,
+          cache_creation_input_tokens INTEGER,
+          cache_read_input_tokens INTEGER,
+          estimated_cost_usd REAL,
+          pricing_status TEXT NOT NULL,
+          llm_call_count INTEGER,
+          metadata_json TEXT
+        );
+        INSERT INTO llm_usage_events (
+          id,
+          created_at,
+          actor,
+          provider,
+          model,
+          input_tokens,
+          output_tokens,
+          pricing_status
+        ) VALUES (
+          'usage-1',
+          1000,
+          'main_agent',
+          'anthropic',
+          'claude-sonnet-4-20250514',
+          100,
+          50,
+          'priced'
+        );
+      `);
+
+      migrateLlmUsageAttribution(db);
+
+      const row = raw
+        .query(
+          /*sql*/ `
+          SELECT call_site, inference_profile, inference_profile_source
+          FROM llm_usage_events
+          WHERE id = 'usage-1'
+        `,
+        )
+        .get() as {
+        call_site: string | null;
+        inference_profile: string | null;
+        inference_profile_source: string | null;
+      };
+      expect(row.call_site).toBeNull();
+      expect(row.inference_profile).toBeNull();
+      expect(row.inference_profile_source).toBeNull();
+    });
+
+    test("idempotency: calling migration twice does not throw", () => {
+      const db = createTestDb();
+      const raw = getRaw(db);
+
+      raw.exec(/*sql*/ `
+        CREATE TABLE llm_usage_events (
+          id TEXT PRIMARY KEY,
+          created_at INTEGER NOT NULL,
+          actor TEXT NOT NULL,
+          provider TEXT NOT NULL,
+          model TEXT NOT NULL,
+          input_tokens INTEGER NOT NULL,
+          output_tokens INTEGER NOT NULL,
+          pricing_status TEXT NOT NULL
+        )
+      `);
+
+      migrateLlmUsageAttribution(db);
+      migrateLlmUsageAttribution(db);
+
+      for (const column of [
+        "call_site",
+        "inference_profile",
+        "inference_profile_source",
+      ]) {
+        const found = raw
+          .query(
+            `SELECT 1 FROM pragma_table_info('llm_usage_events') WHERE name = '${column}'`,
+          )
+          .get();
+        expect(found).toBeTruthy();
+      }
+    });
+  });
+
   // ── v9: downDropActiveSearchIndex ────────────────────────────────────
 
   describe("v9: downDropActiveSearchIndex", () => {

package/src/__tests__/db-slack-compaction-watermark-migration.test.ts

@@ -0,0 +1,169 @@
+import { Database } from "bun:sqlite";
+import { describe, expect, test } from "bun:test";
+
+import { drizzle } from "drizzle-orm/bun-sqlite";
+
+import { getSqliteFrom } from "../memory/db-connection.js";
+import {
+  downSlackCompactionWatermark,
+  migrateSlackCompactionWatermark,
+} from "../memory/migrations/235-slack-compaction-watermark.js";
+import * as schema from "../memory/schema.js";
+
+interface ColumnRow {
+  name: string;
+  type: string;
+  notnull: number;
+}
+
+interface ConversationCompactionRow {
+  id: string;
+  context_summary: string | null;
+  context_compacted_message_count: number;
+  context_compacted_at: number | null;
+  slack_context_compaction_watermark_ts: string | null;
+  slack_context_compaction_watermark_at: number | null;
+}
+
+function createTestDb() {
+  const sqlite = new Database(":memory:");
+  sqlite.exec("PRAGMA journal_mode=WAL");
+  sqlite.exec("PRAGMA foreign_keys = ON");
+  return drizzle(sqlite, { schema });
+}
+
+function bootstrapCheckpointsTable(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE IF NOT EXISTS memory_checkpoints (
+      key TEXT PRIMARY KEY,
+      value TEXT NOT NULL,
+      updated_at INTEGER NOT NULL
+    )
+  `);
+}
+
+function bootstrapLegacyConversations(raw: Database): void {
+  raw.exec(/*sql*/ `
+    CREATE TABLE conversations (
+      id TEXT PRIMARY KEY,
+      title TEXT,
+      created_at INTEGER NOT NULL,
+      updated_at INTEGER NOT NULL,
+      context_summary TEXT,
+      context_compacted_message_count INTEGER NOT NULL DEFAULT 0,
+      context_compacted_at INTEGER
+    )
+  `);
+}
+
+function getConversationColumns(raw: Database): Map<string, ColumnRow> {
+  const columns = raw
+    .query(`PRAGMA table_info(conversations)`)
+    .all() as ColumnRow[];
+  return new Map(columns.map((column) => [column.name, column]));
+}
+
+describe("migrateSlackCompactionWatermark", () => {
+  test("adds nullable Slack watermark columns and preserves existing compaction state", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapLegacyConversations(raw);
+
+    raw
+      .query(
+        /*sql*/ `
+          INSERT INTO conversations (
+            id,
+            title,
+            created_at,
+            updated_at,
+            context_summary,
+            context_compacted_message_count,
+            context_compacted_at
+          ) VALUES (?, ?, ?, ?, ?, ?, ?)
+        `,
+      )
+      .run(
+        "conv-1",
+        "legacy slack thread",
+        1000,
+        2000,
+        "existing compacted summary",
+        42,
+        3000,
+      );
+
+    migrateSlackCompactionWatermark(db);
+
+    const columns = getConversationColumns(raw);
+    expect(columns.get("slack_context_compaction_watermark_ts")).toMatchObject({
+      type: "TEXT",
+      notnull: 0,
+    });
+    expect(columns.get("slack_context_compaction_watermark_at")).toMatchObject({
+      type: "INTEGER",
+      notnull: 0,
+    });
+
+    const row = raw
+      .query(
+        /*sql*/ `
+          SELECT
+            id,
+            context_summary,
+            context_compacted_message_count,
+            context_compacted_at,
+            slack_context_compaction_watermark_ts,
+            slack_context_compaction_watermark_at
+          FROM conversations
+          WHERE id = ?
+        `,
+      )
+      .get("conv-1") as ConversationCompactionRow | null;
+
+    expect(row).toEqual({
+      id: "conv-1",
+      context_summary: "existing compacted summary",
+      context_compacted_message_count: 42,
+      context_compacted_at: 3000,
+      slack_context_compaction_watermark_ts: null,
+      slack_context_compaction_watermark_at: null,
+    });
+  });
+
+  test("is idempotent when columns already exist", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapLegacyConversations(raw);
+    raw.exec(
+      `ALTER TABLE conversations ADD COLUMN slack_context_compaction_watermark_ts TEXT`,
+    );
+    raw.exec(
+      `ALTER TABLE conversations ADD COLUMN slack_context_compaction_watermark_at INTEGER`,
+    );
+
+    expect(() => migrateSlackCompactionWatermark(db)).not.toThrow();
+
+    const columns = getConversationColumns(raw);
+    expect(columns.has("slack_context_compaction_watermark_ts")).toBe(true);
+    expect(columns.has("slack_context_compaction_watermark_at")).toBe(true);
+  });
+
+  test("down migration drops Slack watermark columns and is idempotent", () => {
+    const db = createTestDb();
+    const raw = getSqliteFrom(db);
+    bootstrapCheckpointsTable(raw);
+    bootstrapLegacyConversations(raw);
+
+    migrateSlackCompactionWatermark(db);
+
+    downSlackCompactionWatermark(db);
+    expect(() => downSlackCompactionWatermark(db)).not.toThrow();
+
+    const columns = getConversationColumns(raw);
+    expect(columns.has("slack_context_compaction_watermark_ts")).toBe(false);
+    expect(columns.has("slack_context_compaction_watermark_at")).toBe(false);
+  });
+});